Scala Ucuenca 2
-
Upload
rafael-cobos -
Category
Documents
-
view
69 -
download
1
Transcript of Scala Ucuenca 2
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