SCALA

Introducción

Scala es el acrónimo de “Scalable Language” Es un lenguaje de programación funcional

híbrido Creado por Martin Odersky Primera versión liberada en 2003

Introducción

Integra características de lenguajes orientados a objetos y funcionales

Scala es compilado para ser ejecutado dentro de una Máquina Virtual de Java JVM

Muchas compañías que dependen de Java para aplicaciones críticas están cambiando a Scala para impulsar su productividad de desarrollo, escalabilidad y confiabilidad

Principales características

Scala es un lenguaje puro orientado a objetos (todo valor es un objeto).

Tipos y comportamientos de los objetos son descritos por clases y rasgos (traits).

Scala es funcional, toda función es un valor, todo valor es un objeto, toda función es un objeto.

Provee sintaxis liviana para definir funciones anónimas.

Soporta funciones de orden alto, funciones anidadas y “currying”.

Scala utiliza tipado estático.

Principales características

Corre dentro de una JVM (ByteCode). Comparte el mismo runtime del lenguaje Java.

Scala puede ejectuar código Java.

Diferencias frente a Java

Todos los tipos son objetos. Inferencia de tipos. Funciones anidadas. Funciones son objetos. Domain specific language (DSL) Traits Closures Soporte de concurrencia inspirado en

ERLANG

Sintáxis Básica El caractér de fin de sentencia ; es opcional. Sensibilidad a mayúsculas. Identificadores Hello y

hello son diferentes. Nombres de clases: la primera letra debe ser

mayúscula (MiPrimeraClase). Nombres de métodos: la primera letra debe ser

minúscula (miNombreMetodo) Nombre de programa: Nombre del archivo del

programa debe coincidir con el nombre del objeto (HelloWorld.scala)

def main(args: Array[String]) – Un programa scala debe iniciar desde el método main() el cual es una parte mandatoria para cualquier programa scala.

Sintáxis Básica - Identificadores

Todos los componentes de scala tienen nombre (Objetos, Clases, Variables y métodos)

Existen 4 tipos de identificadores en scala: Alfanuméricos: Operadores Mixtos Literales

Identificadores alfanuméricos

Empiezan con una letra o un underscore, seguido de letras digitos o mas underscores. $ no es permitido Legales: age, salary, _value, __1_value Ilegales: $salary, 123abc, -salary

Identificadores operador

Consiste de uno o mas caracteres operadores + ++ ::: <?> :>

Identificadores mixtos

Consiste de un identificador alfanumérico seguido por un underscore y un operador identificador. unary_+, myvar_=

Identificadores literales

Es una cadena de caracteres arbitraria encerrada entre comillas simples `x` `<clinit>` `yield`

Palabras Clave

Otros elementos de sintaxis

Soporte de comentarios multi línea similar a Java

Scala es un lenguage orientado a líneas. Las sentencias pueden terminar en (;) o nueva línea.

El (;) es opcional. Si dos sentencias están en una misma línea

estas deben ser separadas por (;)

Paquetes

Definición de paquetes similar a java Para importar todo el contenido de un

paquete: import scala.xml._

Para importar una clase específica: import scala.collection.mutable.HashMap

Para importar mas de una clase del mismo paquete: import scala.collection.immutable.{TreeMap,

TreeSet}

Tipos de datos

Tiene los mismos tipos de datos que Java con la salvedad que todos son objetos.

No existen tipos primitivos en el lenguaje

Tipos de datos

Literales basicos de scala

Integer Punto flotante Booleanos Simbolos Caracteres Strings Strings multilínea Valor nulo

Literales Integer

Usualmente de tipo Int, o de tipo Long cuando es seguido por un sufijo L o l 0 035 21 0xFFFFFFFF

Literales de punto flotante

Son de tipo Float cuando es seguido por un sufijo de tipo de punto flotante F o f y son de tipo Double en caso contrario. 0.0 1e30f 3.14159f 1.0e100 .1

Literales de tipo booleano y caracter

true y false son miembros del tipo Boolean. Los literales de tipos caracter son caracteres

simples encerrados entre comillas simples. El caracter puede ser o un caracter unicode

imprimible o un caracter descrito por una secuencia de escapes 'a' '\u0041' '\n' '\t'

Literales string

Es una secuencia de caracteres entre comillas dobles. El caracter puede ser o un caracter unicode imprimible o un caracter descrito por una secuencia de escapes. "Hello,\nWorld!" "This string contains a \" character."

Literales string multiple línea Secuencia de caracteres encerrados entre triple

comillas dobles “”” ... “””. El valor nulo es de tipo scala.Null, representa

el objeto especial null.

Variables

Posee diferentes sintaxis para la declaración de variables.

Pueden ser definidas como valor constante o variable. var myVar : String = "Foo" val myVal : String = "Foo"

Tipos de datos de variables

El tipo de la variable es especificado después del nombre de la variable y antes del signo igual. val or val VariableName : DataType [=Initial Value] var myVar :Int; val myVal :String;

Inferencia de tipos de variables

Cuando se asigna un valor inicial, el compilador de scala puede determinar el tipo de la variable basado en su valor asignado (Inferencia de tipos). var myVar = 10; val myVal = "Hello, Scala!";

Asignaciones múltiples

Scala soporta asignación múltiple Si un bloque de código retorna una “Tupla”,

esta puede ser asignada a una variable “val” val (myVar1: Int, myVar2: String) = Pair(40, "Foo") val (myVar1, myVar2) = Pair(40, "Foo")

Tipos de variables

En scala las variables pueden tener diferentes tipos de ámbitos dependiendo del lugar en donde son usados: Como campos Como parámetros de un método Como variables locales

Variables tipo campo

Son variables que pertenecen a un objeto Son accesibles desde cada método de un

objeto. Son accesibles desde otros objetos

dependiendo de su modificador de acceso. Pueden ser mutables o inmutables (var o val)

Variables como parámetro de un método

Son variables que se pasan a un método cuando este es llamado.

Los parámetros de un método son siempre mutables y definidos con la palabra clave “val”

Variables locales

Son variables declaradas dentro de un método.

Las variables locales pueden ser mutables o inmutables (var o val)

Modificadores de acceso

Miembros de paquetes, clases y objetos pueden ser etiquetados con los modificadores de acceso private y protected.

Si no se utiliza ninguno de los dos se asume un acceso público.

Los modificadores de acceso restringen el acceso a ciertas regiones del código.

Miembros privadosUn miembro private es solo visible desde la propia

clase.

class Outer {

class Inner {

private def f() { println("f") }

class InnerMost {

f() // OK

}

}

(new Inner).f() // Error: f is not accessible

}

Miembros protegidosLos miembros protegidos son accesibles desde las subclases de

una clase en la cual el miembro está definido

package p {

class Super {

protected def f() { println("f") }

}

class Sub extends Super {

f()

}

class Other {

(new Super).f() // Error: f is not accessible

}

}

Miembros públicos

Aquellos miembros que no se encuentran etiquetados con public o private.

class Outer {

class Inner {

def f() { println("f") }

class InnerMost {

f() // OK

}

}

(new Inner).f() // OK because now f() is public

}

Alcance de protección

Los modificadores pueden recibir argumentos como calificadores.

Los modificadores de la forma private[X] o protected[x] significa que su acceso es privado hasta X

X determina el paquete, clase u objeto.

Alcance de protecciónpackage society {

package professional {

class Executive {

private[professional] var workDetails = null

private[society] var friends = null

private[this] var secrets = null

def help(another : Executive) {

println(another.workDetails)

println(another.secrets) //ERROR

}

}

}

}

Scala - Operadores

Un simbolo operador indica al compilador ejectuar una operación matemática o lógica

Scala soporta los operadores:• Aritméticos

• Relacionales

• Lógicos

• A nivel de bit

• Asignación

Operadores aritméticos

Operadores relacionales

Operadores lógicos

Operadores a nivel de bit

Operadores de asignación

Control de flujo

Sentencias condicionales Bucles

Sentencias condicionales - IF

Consiste de una expresión booleana seguida de una o mas sentencias

Sintaxis:

If (Expresion_Booleana)

{//Sentencias se ejecutan si la expresion booleana es true

}

Sentencias condicionales - IF

Ejemplo:object Test {

def main(args: Array[String]) {

var x = 10;

if( x < 20 ){

println("This is if statement");}

}

}

Sentencias condicionales – IF...ELSE

Una sentencia if podría ser seguida de una sentencia opcional else, la cual se ejecuta cuando le expresión booleana se evalua a falso.

if(Boolean_expression){

//Executes when the Boolean expression is true

}else{

//Executes when the Boolean expression is false

}

Sentencias condicionales – if ... else

object Test {

def main(args: Array[String]) {

var x = 30;

If( x < 20 ){

println("This is if statement");

}else{

println("This is else statement");

}

}

}

Sentencias condicionales if ... else if ... else

Una sentencia if opcionalmente puede ser seguida por una sentencia else if.

Sintaxis 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.

}

Sentencias condicionales if ... else if ... else

Ejemplo

object Test {

def main(args: Array[String]) {

var x = 30;

if( x == 10 ){

println("Value of X is 10");

}else if( x == 20 ){

println("Value of X is 20");

}else if( x == 30 ){

println("Value of X is 30");

}else{

println("This is else statement");

}

}

}

Scala – Tipos de Bucles

Tipo de bucle Descripción

while Repite un grupo de sentencias mientras una condicion sea verdadera. Este verifica la condicion antes de ejecutar el cuerpo del bucle

Do ... while Como una sentecia while excepto porque la sentencia es comprobada al final de la ejecución del cuerpo

for Ejecuta una secuencia de sentencias en multiples ocasiones y abrevia el codigo que maneja la variable del bucle

Bucle while

Sintaxis

while(condition){

statement(s);

}

Bucle while

Ejemplo object Test {

def main(args: Array[String]) {

// Local variable declaration:

var a = 10;

// while loop execution

while( a < 20 ){

println( "Value of a: " + a );

a = a + 1;

}

}

}

Bucle do while

Garantiza que se ejecute el bloque de código al menos una vez

Sintaxis:

do{

statement(s);

}while( condition );

Bucle do while

Ejemploobject Test {

def main(args: Array[String]) {

// Local variable declaration:

var a = 10;

// do loop execution

do{

println( "Value of a: " + a );

a = a + 1;

}while( a < 20 )

}

}

Bucle for

Bucle for con Rangos

for( var x <- Range ){

statement(s);

}

Range puede ser un rango de números y que son representados como i to j, o , i until j

El operador flecha izquierda <- es llamado generador, genera valores individuales desde el rango

Bucle for

Ejemplo:object Test {

def main(args:Array[String]) {

var a = 0;

// for loop execution with a range

for( a <- 1 to 10){

println("Value of a: " + a );

}

}

}

Bucle for ... until

Ejemplo:object Test {

def main(args:Array[String]) {

var a = 0;

// for loop execution with a range

for( a <- 1 until 10){

println("Value of a: " + a );

}

}

}

Bucle for ... multiples rangos

object Test {

def main(args: Array[String]) {

var a = 0;

var b = 0;

// for loop execution with a range

for( a <- 1 to 3; b <- 1 to 3){

println("Value of a: " + a );

println("Value of b: " + b );

}

}

}

Bucle for con colecciones

Sintaxis

for( var x <- List ){

statement(s);

}

Bucle for con colecciones

Ejemploobject Test {

def main(args: Array[String]) {

var a = 0;

val numList = List(1,2,3,4,5,6);

// for loop execution with a collection

for( a <- numList ){

println( "Value of a: " + a );

}

}

}

Bucle for con filtros

Sintaxis

for( var x <- List

if condition1; if condition2...

){

statement(s);

}

Para agregar mas condiciones, separarlas con ;

Bucle for con filtros

Ejemploobject Test {

def main(args: Array[String]) {

var a = 0;

val numList = List(1,2,3,4,5,6,7,8,9,10);

// for loop execution with multiple filters

for( a <- numList if a != 3; if a < 8 ){

println( "Value of a: " + a );

}

}

}

Bucle for con yield

Sintaxis

var retVal = for { var x <- List

if condition1; if condition2...

}yield x

Las llaves del for se usan para mantener las variables y condiciones

RetVal contiene los valores producto de la ejecucion del for como una colección

Bucle for con yield

Ejemplo:

Sentencia break

No existe una sentencia como en Java para terminar un bucle

A partir de la versión 2.8 de scala se provee de un mecanismo para implementar este comportamiento

Sentencia break

Sintaxis

Sentencia break

Ejemplo

Scala

Funciones

Scala - Funciones

Es un grupo de sentencias que juntas ejecutan una tarea. Scala soporta funciones y métodos Una función en escala es un objeto completo el cual

puede ser asignado a una variable Una función que es definida como un miembro de algún

objeto es llamada un método. Una definición de una función puede aparacer en

cualquier parte de un código fuente y es permitido anidar funciones

Nombres de funciones pueden contener caracteres como + , ++, ~, &, -, --, \, /

Scala - Funciones

Declaración

Sintaxis

def functionName ([list of parameters]) : [return type]

Definiciones

def functionName ([list of parameters]) : [return type] = {

function body

return [expr]

}

Scala - Funciones

Return Type puede ser cualquier tipo de dato válido de scala

Lista de parámetros es una lista de variables separadas por comas

La lista de parámetros y return type son opcionales.

Ejemplo

Scala - Funciones

Una función que no retorna nada puede retornar Unit que es el equivalente a void en Java. Indica que la función no retorna nada

Scala – Llamada de funciones

Scala provee distintas variaciones sintácticas para invocar a un método.

Sintaxis

functionName( list of parameters )

Scala – Llamada de funciones

Si una función es llamada usando una instancia de un objeto deberíamos utilizar la notación de punto similar a Java.

Sintaxis

[instance.]functionName( list of parameters )

Scala – Llamada de funciones

Ejemplo

Scala - Closures

Es una función cuyo valor de retorno depende del valor de una o más variables declaradas fuera de esta función

val multiplier = (i:Int) => i * 10

val multiplier = (i:Int) => i * factor

var factor = 3

val multiplier = (i:Int) => i * factor

object Test {

def main(args: Array[String]) {

println( "muliplier(1) value = " + multiplier(1) )

println( "muliplier(2) value = " + multiplier(2) )

}

var factor = 3

val multiplier = (i:Int) => i * factor

}

Scala-Strings

En Scala, como en Java, una cadena es un objeto inmutable, no se puede modificar. Para hacer modificaciones se usa String Builder.

Scala - Strings

Longitud

Concatenar

Scala-Strings

Formateando Strings

Scala-Arrays

Scala ofrece una estructura de datos, el arreglo, que almacena una colección secuencial de tamaño fijo de elementos del mismo tipo.

Declaración

Scala-Arrays

Scala-Arrays

Arreglo multidimensional

Concatenar

Arreglo con

rango

Scala-Collections

Scala tiene un rico conjunto de colección de la biblioteca. Las colecciones son contenedores de cosas. Los contenedores pueden ser secuenciados, los conjuntos lineales de artículos como List, Tuple, Option, Map etc. Las colecciones pueden tener un número arbitrario de elementos o estar delimitado a cero o elemento de una (por ejemplo, opción).

Las colecciones pueden ser strict or lazy. Lazy colecciones tienen elementos que no pueden consumir la memoria hasta que se accede a ellos, como rangos. Además, las colecciones pueden ser mutable (el contenido de la referencia se puede cambiar) o inmutable (lo que se refiere a una referencia no se cambia nunca). Tenga en cuenta que las colecciones inmutables puede contener items mutables.

Scala-Collections

Scala-Collections

Scala-Clases y ObjetosUna clase es un modelo para los objetos. Una vez

que se define una clase, puede crear objetos a partir de la clase con la palabra clave new.

Scala-ClasesHerencia

Scala-ClasesSingleton

Scala es más orientado a objetos de Java en Scala porque no podemos tener miembros estáticos. En su lugar, Scala tiene objetos únicos.

Un singleton es una clase que sólo puede tener un ejemplo de instancia. objeto. Se crea el objeto con la palabra clave singleton en lugar de palabra clave class.

No puede crear instancias de un objeto único, no se puede pasar parámetros al constructor principal.

Scala-Clases

Scala-TraitsUn trait encapsula definiciones de métodos y de atributo,

que luego pueden ser reutilizados por mezclándolos en clases. A diferencia de la herencia de clases, en el que cada clase debe heredar de una sola superclase, una clase puede mezclar en cualquier número de traits.

Los traits se utilizan para definir los tipos de objetos mediante la especificación de la firma de los métodos admitidos.

Los traits pueden ser parcialmente implementados, pero no pueden tener parámetros de constructor.

Scala-Traits

Scala-Pattern Matching

Pattern matching es la segunda característica más utilizada de Scala, después de valores de function y closures..

Una pattern matching incluye una secuencia de alternativas, cada uno comenzando con la palabra clave case. Cada alternativa incluye un patrón y las expresiones uno o más, que se evaluará si el patrón coincide. Un símbolo de flecha => separa el patrón de las expresiones.

Scala-Pattern Matching

Scala-Matching using case ClassesLas clases case son clases especiales que se

utilizan en la comparación de patrones con expresiones case. Sintácticamente, estas son las clases estándar con un modificador especial: case

Scala-Regular Expressions

Scala soporta expresiones regulares con Regex classe disponibles en el paquete scala.util.matching

Scala-Regular Expressions

Scala-Regular Expressions

Scala-Exception Handling

• Las excepciones en Scala funcionan como excepciones en muchos otros lenguajes como Java. En lugar de devolver un valor de manera normal, un método puede terminar lanzando una excepción.

• Scala en realidad no comprueba excepciones.

• Si desea controlar las excepciones se utiliza un try {...} catch {...} bloque como lo haría en Java, salvo que el bloque catch coincidente se utiliza para identificar y manejar las excepciones.

Scala- Handling exceptions

• Throwing exceptions:

Lanzar una excepción es como en Java. Se crea un objeto de excepción y luego lo lanza con la palabra clave throw:

throw new IllegalArgumentException

• Catching exceptions:

Scala usa try / catch para cualquier excepción en un solo bloque y ejecuta pattern matching usando el bloque case.

Scala-Handling exceptions

Scala-Handling exceptions

Puede utilizar una expresión con una cláusula finally si quiere hacer algo de código que se ejecutará independientemente de cómo la expresión termina.

Scala- Files I/O

• Scala está abierta para hacer uso de cualquier objetos Java y java.io.File es uno de los objetos que pueden ser utilizados en la programación Scala para leer y escribir archivos.

Scala-Files I/O

• Leyendo desde

consola

• Leyendo el contenido

de un archivo