Scala Language Tutorial
Empezando con Scala Language
Buscar..
Observaciones
Scala es un moderno lenguaje de programación multi-paradigma diseñado para expresar patrones de programación comunes de una manera concisa, elegante y segura. Se integra sin problemas las características de los lenguajes orientados a objetos y funcionales .
La mayoría de los ejemplos dados requieren una instalación de Scala en funcionamiento. Esta es la página de instalación de Scala , y este es el ejemplo 'Cómo configurar Scala' . scalafiddle.net es un buen recurso para ejecutar pequeños ejemplos de código en la web.
Versiones
Versión | Fecha de lanzamiento |
---|---|
2.10.1 | 2013-03-13 |
2.10.2 | 2013-06-06 |
2.10.3 | 2013-10-01 |
2.10.4 | 2014-03-24 |
2.10.5 | 2015-03-05 |
2.10.6 | 2015-09-18 |
2.11.0 | 2014-04-21 |
2.11.1 | 2014-05-21 |
2.11.2 | 2014-07-24 |
2.11.4 | 2014-10-30 |
2.11.5 | 2014-01-14 |
2.11.6 | 2015-03-05 |
2.11.7 | 2015-06-23 |
2.11.8 | 2016-03-08 |
2.11.11 | 2017-04-19 |
2.12.0 | 2016-11-03 |
2.12.1 | 2016-12-06 |
2.12.2 | 2017-04-19 |
Hola mundo definiendo un método 'principal'
Coloque este código en un archivo llamado HelloWorld.scala
:
object Hello {
def main(args: Array[String]): Unit = {
println("Hello World!")
}
}
Para compilarlo a bytecode que es ejecutable por la JVM:
$ scalac HelloWorld.scala
Para ejecutarlo:
$ scala Hello
Cuando el tiempo de ejecución de Scala carga el programa, busca un objeto llamado Hello
con un método main
. El método main
es el punto de entrada del programa y se ejecuta.
Tenga en cuenta que, a diferencia de Java, Scala no tiene el requisito de nombrar objetos o clases después del archivo en el que se encuentran. En su lugar, el parámetro Hello
pasó en el comando scala Hello
refiere al objeto que se busca que contiene el método main
que se ejecutará. Es perfectamente posible tener varios objetos con métodos principales en el mismo archivo .scala
.
La matriz args
contendrá los argumentos de línea de comando dados al programa, si los hay. Por ejemplo, podemos modificar el programa así:
object HelloWorld {
def main(args: Array[String]): Unit = {
println("Hello World!")
for {
arg <- args
} println(s"Arg=$arg")
}
}
Compilarlo
$ scalac HelloWorld.scala
Y luego ejecutarlo:
$ scala HelloWorld 1 2 3
Hello World!
Arg=1
Arg=2
Arg=3
Hola mundo extendiendo la aplicación
object HelloWorld extends App {
println("Hello, world!")
}
Al extender el rasgo de la App
, puede evitar definir un método main
explícito. Todo el cuerpo del objeto HelloWorld
se trata como "el método principal".
Inicialización retrasada
Según la documentación oficial , la
App
hace uso de una función llamada Inicialización diferida . Esto significa que los campos de objeto se inicializan después de llamar al método principal.
Inicialización retrasada
Según la documentación oficial , la
App
hace uso de una función llamada Inicialización diferida . Esto significa que los campos de objeto se inicializan después de llamar al método principal.
DelayedInit
ahora está en desuso para uso general, pero todavía es compatible con laApp
como un caso especial. El soporte continuará hasta que se decida e implemente una función de reemplazo.
Para acceder a los argumentos de la línea de comandos al extender la App
, use this.args
:
object HelloWorld extends App {
println("Hello World!")
for {
arg <- this.args
} println(s"Arg=$arg")
}
Al usar la App
, el cuerpo del objeto se ejecutará como el método main
, no hay necesidad de anular main
.
Hola mundo como guión
Scala puede ser usado como un lenguaje de scripting. Para demostrarlo, cree HelloWorld.scala
con el siguiente contenido:
println("Hello")
Ejecútelo con el intérprete de línea de comandos (el $
es el indicador de línea de comandos):
$ scala HelloWorld.scala
Hello
Si omite .scala
(como si simplemente escribió scala HelloWorld
) el corredor buscará un archivo .class
compilado con .scala
lugar de compilar y luego ejecutar el script.
Nota: Si se usa scala como lenguaje de scripting, no se puede definir ningún paquete.
En los sistemas operativos que utilizan bash
o terminales de shell similares, los scripts de Scala se pueden ejecutar utilizando un 'preámbulo de shell'. Cree un archivo llamado HelloWorld.sh
y coloque lo siguiente como contenido:
#!/bin/sh
exec scala "$0" "$@"
!#
println("Hello")
Las partes entre #!
y !#
es el 'preámbulo de shell', y se interpreta como un script bash. El resto es Scala.
Una vez que haya guardado el archivo anterior, debe otorgarle permisos 'ejecutables'. En la cáscara puedes hacer esto:
$ chmod a+x HelloWorld.sh
(Tenga en cuenta que esto le da permiso a todos: lea acerca de chmod para aprender cómo configurarlo para conjuntos de usuarios más específicos).
Ahora puedes ejecutar el script así:
$ ./HelloWorld.sh
Usando el Scala REPL
Cuando ejecuta scala
en un terminal sin parámetros adicionales, se abre un intérprete REPL (Read-Eval-Print Loop):
nford:~ $ scala
Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_66).
Type in expressions for evaluation. Or try :help.
scala>
El REPL le permite ejecutar Scala en forma de hoja de trabajo: el contexto de ejecución se conserva y puede probar los comandos manualmente sin tener que construir un programa completo. Por ejemplo, al escribir val poem = "As halcyons we shall be"
se vería así:
scala> val poem = "As halcyons we shall be"
poem: String = As halcyons we shall be
Ahora podemos imprimir nuestro val
:
scala> print(poem)
As halcyons we shall be
Tenga en cuenta que val
es inmutable y no se puede sobrescribir:
scala> poem = "Brooding on the open sea"
<console>:12: error: reassignment to val
poem = "Brooding on the open sea"
Pero en el REPL puede redefinir un valor val
(lo que causaría un error en un programa Scala normal, si se realizó en el mismo ámbito):
scala> val poem = "Brooding on the open sea"
poem: String = Brooding on the open sea
Para el resto de su sesión REPL, esta variable recién definida sombreará la variable previamente definida. Los REPL son útiles para ver rápidamente cómo funcionan los objetos u otros códigos. Todas las funciones de Scala están disponibles: puede definir funciones, clases, métodos, etc.
Scala Quicksheet
Descripción | Código |
---|---|
Asignar valor int inmutable | val x = 3 |
Asignar valor int mutable | var x = 3 |
Asignar valor inmutable con tipo explícito | val x: Int = 27 |
Asignar valor perezosamente evaluado | lazy val y = print("Sleeping in.") |
Vincular una función a un nombre | val f = (x: Int) => x * x |
Enlazar una función a un nombre con tipo explícito | val f: Int => Int = (x: Int) => x * x |
Define un método | def f(x: Int) = x * x |
Definir un método con tipificación explícita. | def f(x: Int): Int = x * x |
Define una clase | class Hopper(someParam: Int) { ... } |
Define un objeto | object Hopper(someParam: Int) { ... } |
Definir un rasgo | trait Grace { ... } |
Obtener primer elemento de secuencia | Seq(1,2,3).head |
Si interruptor | val result = if(x > 0) "Positive!" |
Obtener todos los elementos de secuencia excepto primero | Seq(1,2,3).tail |
Recorrer una lista | for { x <- Seq(1,2,3) } print(x) |
Bucle anidado | for { |
Para cada elemento de lista ejecutar la función. | List(1,2,3).foreach { println } |
Imprimir a estándar | print("Ada Lovelace") |
Ordenar una lista alfanuméricamente | List('b','c','a').sorted |