Para dar inicio al lenguaje Scala el mejor ejemplo de programación es el clásico hola mundo, en este ejemplo tenemos un objeto sencillo con su metodo obligatorio main(), en el cual se imprimirá un "Hello world!" sencillo, en donde se notan similitudes con java. En Scala es opcional el punto y coma(;)
object HelloWorld {
def main(args: Array[String]) {
println("Hello, world!")
}
}
En Scala las variables puden ser mutables o inmutables declarándolas con la palabra reservada var o val correspondientemente. Se puede declarar variables sin indicar el tipo(inferencia en tipo de variable):
val o val VariableName : DataType = [Initial Value]
La sentencia if..else es parecido que en java
if(Boolean_expression 1){
//Executes when the Boolean expression 1 is true
} else if(Boolean_expression 2){
//Executes when the Boolean expression 2 is true
} else if(Boolean_expression 3){
//Executes when the Boolean expression 3 is true
} else {
//Executes when the none of the above condition is true.
}
El equivalente al switch..case de java. La variable a evaluar va antes de match. permite comparación con distintos tipos de datos. case _ es el respectivo default de java.
variable match{
case opcion => code
case _ => code default
}
while(condition){
statement(s);
}
do {
statement(s);
}
while( condition );
Para definir el rango hay varias opciones: to j es inclusivo, until j es exclusivo, podemos iterar sobre varias variables(equivalente a for anidados), también se puede iterar sobre colecciones y con salto con by k.
for( var x <- Range ){
statement(s);
}
Algo muy útil que tiene vaya es el for con filtros, esto nos ahorra escribiendo if dentro del for.
for( var x <- List
if condition1; if condition2...
){
statement(s);
}
Si lo que se quiere es guardar los valores del loop se puede usar yield
var retVal = for{ var x <- List
if condition1; if condition2...
}
yield x
Esparecido a los arrays de java con la diferencia que son inmutables y representan una lista de enlaces en vez de arreglos planos.
val nombreLista: List[tipo] = List(valores)
| Métodos básicos | Descripción |
|---|---|
| head | Retorna en primer elemento |
| tail | Retorna todos los elementos exceptuando el primero |
| isEmpty | Retorna verdaddero si es vacío |
Es una colección de elementos no duplicados, puede ser mutable o inmutable, para uso mutable es necesario importar la clase scala.collection.mutable.Set.
var s : Set[tipo] = Set()
var s : Set[tipo] = Set(valores)
var s = Set(valores)
| Métodos básicos | Descripción |
|---|---|
| head | Retorna en primer elemento |
| tail | Retorna todos los elementos exceptuando el primero |
| isEmpty | Retorna verdaddero si es vacío |
Colecciones de pares de llave/valor donde las llaves son únicas, también llamados tablas hash, puedes ser mutables o inmutables, para usar de manera mutable se debe importar la clase scala.collection.mutable.Map
var A:Map[tipoLlave,tipoValor] = Map()
A + = (llave -> valor)
| Métodos básicos | Descripción |
|---|---|
| keys | Retorna un iterable sobre cada llave |
| values | Retorna un iterable sobre casa valor |
| isEmpty | Retorna verdaddero si es vacío |
Colección de un número fijo de items que pueden ser de distinto tipo pero son inmutables, para acceder a un item se usa t._n para el item n.
val t = (item1, item2, item3)
val t = new Tuple3(item1, item2, item3)
Contenedor de cero o un elemento de un tipo dado. Puede ser objeto Some[T] o None La colección Options es la que define el retorno de los diferentes metodos usados en Scala, y tiene diferentes retornos dependiendo el método.
def findPerson(key: Int): Option[Person]
No es propiamente una colección, sino una forma de acceder a los elementos de una colección uno por uno.
ejemplo en compilador onlineScala tiene funciones y métodos con una diferencia menor. Un método en Scala es una parte de una clase que tiene un nombre, una firma, opcionalmente algunas anotaciones, y algún bytecode, y una función en Scala es un objeto completo que se puede asignar a una variable. En otras palabras, una función que se define como miembro de algún objeto, se llama un método.
def functionName ([list of parameters]) : [return type] = {
function body
return [expr]
}
Tiene como mecanismo pasar un bloque de código como llamada, y cada vez que la llamada accesa a un parámetro este código de bloque es ejecutado. Esto quiere decir que se define el parámetro de una función como otra función que será llamada cada vez que se necesite el parámetro.
funcion(otraFuncion())
Scala permite indicar a una función que el último parámetro de la función puede repetirse, permitiendo como parámetro listas con tamaño variable a una función, ejecutando dicha entrada de forma deseada.
def nombreFuncion( args:tipoDato* )
Scala permite especificar valores por defecto para parámetros de función, en cuyo caso el parámetro puede ser omitido opcionalmente al llamar la función, y se utilizarán los valores de los parámetros marcados por defecto. def addInt( a:Int = 5, b:Int = 7 )
def nombreFuncion ( var1: tipo1 = valor1, var2: tipo2 = valor2 )
Scala permite definir funciones dentro de otras funciones, estas son llamadas funciones locales.
def nombreFuncion1 ([parametros funcion1 ]) : [tipo de retorno1] = {
def nombreFuncion2([parametros funcion2]): [tipo de retorno2]={
...
}
...
}
Cuando se invoca una función puede no ser necesario pasar siempre los argumentos, sobre todo si algunos de estos se repiten. Así se crea una función que encapsula otra, y manda unos parámetros por defecto y otros directamente.
val nombreVariable = nombreFuncion(parametro, _ : tipoDato)
nombreVariable(parametro de tipoDato)
Permite pasar a una función argumentos en diferente orden a los declarados.
def nombreFuncion( nombreVariable1: TipoDato1, nombreVariable2: TipoDato2 ) = {
...
}
nombreFuncion(nombreVariablex = valorx, nombreVariablex = valorx);
Scala soporta recursión de funciones muy bien, esto quiere decir que una función puede llamarse a sí misma repetidamente.
def nombreFuncion(nombreVariable: tipoDato): tipoRetorno = {
...
nombrefuncion(valorParametro)
}
Nos permite pasar funciones como argumentos y/o retornarlos como resultado, las funciones son valores de primera clase. Dichas funciones que reciben o retornan otras funciones son las llamas de Orden Superior. Las funciones de primera clase sólo manejan datos simple como enteros, longs, listas, etc. Toma el valor v y le aplica la funcion f:
nombreFuncion1(nombreFuncion2, valorParametro)
def nombreFuncion2(f: tipoParametro => tipoFuncion2, v: tipoPArametro){
...
}
También llamadas funciones literales, al momento de ejecutarse son instanciadas en objetos llamados valores de función. Simplemente son funciones que al ejecutar el programa son guardadas en objetos tipo var.
var nombreFuncion = (nombreParametro: tipoParametro) => operacion
Trata de hacer la sintaxis de funciones más sencilla de escribir. Re definición de parámetros: Minimizar parámetros entrantes a función, o reacomodación de sintaxis:
def nombreFuncion(s1: tipoDato)(s2: tipoDato) = s1 + s2
def nombreFuncion(s1: tipoDato) = (s2: tipoDato) => s1 + s2
En este ejemplo la clase punto define dos variables xy y el método move:
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
object Demo {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// Move to a new location
pt.move(10, 10);
}
}