Scala - Guía rápida
Scala, abreviatura de Scalable Language, es un lenguaje de programación funcional híbrido. Fue creado por Martin Odersky. Scala integra sin problemas las características de los lenguajes funcionales y orientados a objetos. Scala está compilado para ejecutarse en la máquina virtual Java. Muchas empresas existentes, que dependen de Java para aplicaciones comerciales críticas, están recurriendo a Scala para aumentar su productividad de desarrollo, escalabilidad de aplicaciones y confiabilidad general.
Aquí presentamos algunos puntos que hacen de Scala la primera elección de los desarrolladores de aplicaciones.
Scala está orientado a objetos
Scala es un lenguaje puro orientado a objetos en el sentido de que cada valor es un objeto. Los tipos y el comportamiento de los objetos se describen mediante clases y rasgos que se explicarán en los capítulos siguientes.
Las clases se amplían en subclassing y un flexible mixin-based composition mecanismo como un reemplazo limpio para la herencia múltiple.
Scala es funcional
Scala también es un lenguaje funcional en el sentido de que cada función es un valor y cada valor es un objeto, por lo que, en última instancia, cada función es un objeto.
Scala proporciona una sintaxis ligera para definir anonymous functions, es compatible higher-order functions, permite que las funciones sean nestedy apoya currying. Estos conceptos se explicarán en capítulos posteriores.
Scala se escribe estáticamente
Scala, a diferencia de algunos de los otros lenguajes escritos estáticamente (C, Pascal, Rust, etc.), no espera que proporcione información de tipo redundante. No es necesario que especifique un tipo en la mayoría de los casos y ciertamente no es necesario que lo repita.
Scala se ejecuta en la JVM
Scala se compila en código de bytes de Java que es ejecutado por la máquina virtual de Java (JVM). Esto significa que Scala y Java tienen una plataforma de ejecución común. Puede pasar fácilmente de Java a Scala.
El compilador de Scala compila su código de Scala en código de bytes de Java, que luego puede ser ejecutado por el 'scala'comando. Los 'scala'comando es similar al java comando, ya que ejecuta su código compilado de Scala.
Scala puede ejecutar código Java
Scala le permite utilizar todas las clases del SDK de Java y también sus propias clases de Java personalizadas o sus proyectos favoritos de código abierto de Java.
Scala puede realizar procesamiento simultáneo y sincronizado
Scala le permite expresar patrones generales de programación de una manera eficaz. Reduce el número de líneas y ayuda al programador a codificar de forma segura. Te permite escribir códigos de manera inmutable, lo que facilita la aplicación de simultaneidad y paralelismo (Sincronizar).
Scala vs Java
Scala tiene un conjunto de características que difieren completamente de Java. Algunos de estos son:
- Todos los tipos son objetos
- Inferencia de tipo
- Funciones anidadas
- Las funciones son objetos
- Soporte de lenguaje específico de dominio (DSL)
- Traits
- Closures
- Soporte de concurrencia inspirado en Erlang
Frameworks de Scala Web
Scala se utiliza en todas partes y, de manera importante, en aplicaciones web empresariales. Puede consultar algunos de los marcos web de Scala más populares:
El marco de elevación
El marco de juego
El marco de Bowler
Scala se puede instalar en cualquier sistema basado en Windows o con sabor a UNIX. Antes de comenzar a instalar Scala en su máquina, debe tener Java 1.8 o superior instalado en su computadora.
Siga los pasos que se indican a continuación para instalar Scala.
Paso 1: Verifique su instalación de Java
En primer lugar, debe tener el kit de desarrollo de software Java (SDK) instalado en su sistema. Para verificar esto, ejecute cualquiera de los siguientes dos comandos dependiendo de la plataforma en la que esté trabajando.
Si la instalación de Java se ha realizado correctamente, mostrará la versión actual y la especificación de su instalación de Java. En la siguiente tabla se proporciona un resultado de muestra.
Plataforma | Mando | Salida de muestra |
---|---|---|
Ventanas | Abra la consola de comandos y escriba - \>java –version |
Versión de Java "1.8.0_31" Tiempo de ejecución de Java (TM) SE Entorno (compilación 1.8.0_31-b31) Servidor Java Hotspot (TM) de 64 bits VM (compilación 25.31-b07, modo mixto) |
Linux | Abra el terminal de comando y escriba - $java –version |
Versión de Java "1.8.0_31" Entorno de tiempo de ejecución abierto de JDK (rhel-2.8.10.4.el6_4-x86_64) Abra la máquina virtual del servidor JDK de 64 bits (compilación 25.31-b07, modo mixto) |
Suponemos que los lectores de este tutorial tienen la versión 1.8.0_31 del SDK de Java instalada en su sistema.
En caso de que no tenga Java SDK, descargue su versión actual desde http://www.oracle.com/technetwork/java/javase/downloads/index.html e instalarlo.
Paso 2: configura tu entorno Java
Configure la variable de entorno JAVA_HOME para que apunte a la ubicación del directorio base donde está instalado Java en su máquina. Por ejemplo,
No Señor | Plataforma y descripción |
---|---|
1 | Windows Establezca JAVA_HOME en C: \ ProgramFiles \ java \ jdk1.7.0_60 |
2 | Linux Exportar JAVA_HOME = / usr / local / java-current |
Agregue la ruta completa de la ubicación del compilador de Java a la ruta del sistema.
No Señor | Plataforma y descripción |
---|---|
1 | Windows Agregue la cadena "C: \ Archivos de programa \ Java \ jdk1.7.0_60 \ bin" al final de la variable de sistema PATH. |
2 | Linux Exportar RUTA = $ RUTA: $ JAVA_HOME / bin / |
Ejecuta el comando java -version desde el símbolo del sistema como se explicó anteriormente.
Paso 3: instalar Scala
Puede descargar Scala desde http://www.scala-lang.org/downloads. En el momento de escribir este tutorial, descargué 'scala-2.11.5-installer.jar'. Asegúrese de tener privilegios de administrador para continuar. Ahora, ejecute el siguiente comando en el símbolo del sistema:
Plataforma | Comando y salida | Descripción |
---|---|---|
Ventanas | \> java –jar scala-2.11.5-installer.jar \> |
Este comando mostrará un asistente de instalación, que lo guiará para instalar Scala en su máquina con Windows. Durante la instalación, le pedirá un acuerdo de licencia, simplemente acéptelo y además le pedirá una ruta donde se instalará Scala. Seleccioné la ruta predeterminada "C: \ Archivos de programa \ Scala", puede seleccionar una ruta adecuada según su conveniencia. |
Linux | Command - $ java –jar scala-2.9.0.1-installer.jar Output - ¡Bienvenido a la instalación de Scala 2.9.0.1! La página de inicio está en - http://Scala-lang.org/ presione 1 para continuar, 2 para salir, 3 para volver a mostrar 1 ................................................ [Empezando a desempacar] [Paquete de procesamiento: instalación del paquete de software (1/1)] [Desembalaje terminado] [Instalación de la consola completada] |
Durante la instalación, pedirá acuerdo de licencia, para aceptarlo teclee 1 y preguntará una ruta donde se instalará Scala. Entré en / usr / local / share, se puede seleccionar una ruta adecuada según su conveniencia. |
Finalmente, abra un nuevo símbolo del sistema y escriba Scala -versiony presione Entrar. Debería ver lo siguiente:
Plataforma | Mando | Salida |
---|---|---|
Ventanas | \> scala -version |
Scala code runner versión 2.11.5 - Copyright 2002-2013, LAMP / EPFL |
Linux | $ scala -version |
Scala code runner versión 2.9.0.1 - Copyright 2002-2013, LAMP / EPFL |
Si tiene un buen conocimiento de Java, entonces será muy fácil para usted aprender Scala. La mayor diferencia sintáctica entre Scala y Java es que el ';' El carácter de fin de línea es opcional.
Cuando consideramos un programa Scala, se puede definir como una colección de objetos que se comunican invocando los métodos de los demás. Veamos ahora brevemente qué significan clases, objetos, métodos y variables de instancia.
Object- Los objetos tienen estados y comportamientos. Un objeto es una instancia de una clase. Ejemplo: un perro tiene estados (color, nombre, raza y comportamientos): menear, ladrar y comer.
Class - Una clase se puede definir como una plantilla / plano que describe los comportamientos / estados relacionados con la clase.
Methods- Un método es básicamente un comportamiento. Una clase puede contener muchos métodos. Es en los métodos donde se escriben las lógicas, se manipulan los datos y se ejecutan todas las acciones.
Fields- Cada objeto tiene su conjunto único de variables de instancia, que se denominan campos. El estado de un objeto se crea mediante los valores asignados a estos campos.
Closure - A closure es una función, cuyo valor de retorno depende del valor de una o más variables declaradas fuera de esta función.
Traits- Un rasgo encapsula las definiciones de método y campo, que luego se pueden reutilizar mezclándolos en clases. Los rasgos se utilizan para definir tipos de objetos especificando la firma de los métodos admitidos.
Primer programa Scala
Podemos ejecutar un programa Scala en dos modos: uno es interactive mode y otro es script mode.
Modo interactivo
Abra el símbolo del sistema y use el siguiente comando para abrir Scala.
\>scala
Si Scala está instalado en su sistema, se mostrará el siguiente resultado:
Welcome to Scala version 2.9.0.1
Type in expressions to have them evaluated.
Type :help for more information.
Escriba el siguiente texto a la derecha del indicador de Scala y presione la tecla Intro -
scala> println("Hello, Scala!");
Producirá el siguiente resultado:
Hello, Scala!
Modo de secuencia de comandos
Utilice las siguientes instrucciones para escribir un programa Scala en modo script. Abra el bloc de notas y agregue el siguiente código.
Ejemplo
object HelloWorld {
/* This is my first java program.
* This will print 'Hello World' as the output
*/
def main(args: Array[String]) {
println("Hello, world!") // prints Hello World
}
}
Guarde el archivo como - HelloWorld.scala.
Abra la ventana del símbolo del sistema y vaya al directorio donde se guarda el archivo del programa. Los 'scalacEl comando 'se usa para compilar el programa Scala y generará algunos archivos de clase en el directorio actual. Uno de ellos se llamaráHelloWorld.class. Este es un código de bytes que se ejecutará en Java Virtual Machine (JVM) usando 'scala'comando.
Utilice el siguiente comando para compilar y ejecutar su programa Scala.
\> scalac HelloWorld.scala
\> scala HelloWorld
Salida
Hello, World!
Sintaxis básica
Las siguientes son las sintaxis básicas y las convenciones de codificación en la programación de Scala.
Case Sensitivity - Scala distingue entre mayúsculas y minúsculas, lo que significa identificador Hello y hello tendría un significado diferente en Scala.
Class Names- Para todos los nombres de clases, la primera letra debe estar en mayúsculas. Si se utilizan varias palabras para formar un nombre de la clase, la primera letra de cada palabra interior debe estar en mayúsculas.
Example - clase MyFirstScalaClass.
Method Names- Todos los nombres de métodos deben comenzar con una letra minúscula. Si se utilizan varias palabras para formar el nombre del método, la primera letra de cada palabra interior debe estar en mayúsculas.
Example - def myMethodName ()
Program File Name- El nombre del archivo de programa debe coincidir exactamente con el nombre del objeto. Al guardar el archivo, debe guardarlo usando el nombre del objeto (recuerde que Scala distingue entre mayúsculas y minúsculas) y agregar '.scala'al final del nombre. (Si el nombre del archivo y el nombre del objeto no coinciden, su programa no se compilará).
Example- Suponga que 'HelloWorld' es el nombre del objeto. Luego, el archivo debe guardarse como 'HelloWorld.scala'.
def main(args: Array[String]) - El procesamiento del programa Scala comienza desde el método main () que es una parte obligatoria de cada programa Scala.
Identificadores Scala
Todos los componentes de Scala requieren nombres. Los nombres utilizados para objetos, clases, variables y métodos se denominan identificadores. Una palabra clave no se puede utilizar como identificador y los identificadores distinguen entre mayúsculas y minúsculas. Scala admite cuatro tipos de identificadores.
Identificadores alfanuméricos
Un identificador alfanumérico comienza con una letra o un guión bajo, que puede ir seguido de más letras, dígitos o guiones bajos. El carácter '$' es una palabra clave reservada en Scala y no debe usarse en identificadores.
Los siguientes son legal alphanumeric identifiers -
age, salary, _value, __1_value
Los siguientes son illegal identifiers -
$salary, 123abc, -salary
Identificadores de operador
Un identificador de operador consta de uno o más caracteres de operador. Los caracteres de operador son caracteres ASCII imprimibles como +,:,?, ~ O #.
Los siguientes son identificadores de operador legales:
+ ++ ::: <?> :>
El compilador de Scala "manipulará" internamente los identificadores de operador para convertirlos en identificadores legales de Java con caracteres $ incrustados. Por ejemplo, el identificador: -> se representaría internamente como$colon$menos $ mayor.
Identificadores mixtos
Un identificador mixto consta de un identificador alfanumérico, seguido de un guión bajo y un identificador de operador.
Los siguientes son identificadores mixtos legales:
unary_+, myvar_=
Aquí, unary_ + usado como nombre de método define un operador unario + y myvar_ = usado como nombre de método define un operador de asignación (sobrecarga de operador).
Identificadores literales
Un identificador literal es una cadena arbitraria encerrada entre tics inversos (`...`).
A continuación se muestran identificadores literales legales:
`x` `<clinit>` `yield`
Palabras clave Scala
La siguiente lista muestra las palabras reservadas en Scala. Estas palabras reservadas no se pueden utilizar como constantes o variables o cualquier otro nombre de identificación.
resumen | caso | captura | clase |
def | hacer | más | extiende |
falso | final | finalmente | para |
para algunos | Si | implícito | importar |
perezoso | partido | nuevo | Nulo |
objeto | anular | paquete | privado |
protegido | regreso | sellado | súper |
esta | lanzar | rasgo | Tratar |
cierto | tipo | val | Var |
mientras | con | rendimiento | |
- | : | = | => |
<- | <: | <% | >: |
# | @ |
Comentarios en Scala
Scala admite comentarios de una sola línea y de varias líneas, muy similar a Java. Los comentarios de varias líneas pueden estar anidados, pero es necesario que estén anidados correctamente. Todos los caracteres disponibles dentro de cualquier comentario son ignorados por el compilador de Scala.
object HelloWorld {
/* This is my first java program.
* This will print 'Hello World' as the output
* This is an example of multi-line comments.
*/
def main(args: Array[String]) {
// Prints Hello World
// This is also an example of single line comment.
println("Hello, world!")
}
}
Líneas en blanco y espacios en blanco
Una línea que contiene solo espacios en blanco, posiblemente con un comentario, se conoce como línea en blanco y Scala la ignora por completo. Los tokens pueden estar separados por espacios en blanco y / o comentarios.
Personajes de nueva línea
Scala es un lenguaje orientado a líneas donde las sentencias pueden terminar con punto y coma (;) o líneas nuevas. Un punto y coma al final de una declaración suele ser opcional. Puede escribir uno si lo desea, pero no tiene que hacerlo si la declaración aparece sola en una sola línea. Por otro lado, se requiere un punto y coma si escribe varias declaraciones en una sola línea. La siguiente sintaxis es el uso de varias declaraciones.
val s = "hello"; println(s)
Paquetes de vacaciones en Scala
Un paquete es un módulo de código con nombre. Por ejemplo, el paquete de utilidades Lift es net.liftweb.util. La declaración del paquete es la primera línea sin comentarios en el archivo fuente de la siguiente manera:
package com.liftcode.stuff
Los paquetes de Scala se pueden importar para que se pueda hacer referencia a ellos en el ámbito de compilación actual. La siguiente declaración importa el contenido del paquete scala.xml:
import scala.xml._
Puede importar una sola clase y objeto, por ejemplo, HashMap desde el paquete scala.collection.mutable -
import scala.collection.mutable.HashMap
Puede importar más de una clase u objeto de un solo paquete, por ejemplo, TreeMap y TreeSet del paquete scala.collection.immutable -
import scala.collection.immutable.{TreeMap, TreeSet}
Aplicar dinámico
Un rasgo de marcador que permite invocaciones dinámicas. Las instancias x de este rasgo permiten invocaciones de métodos x.meth (args) para nombres de métodos arbitrarios meth y listas de argumentos args, así como accesos a campos x.field para nombres de campos arbitrarios. Esta característica se introduce en Scala-2.10.
Si una llamada no es compatible de forma nativa con x (es decir, si la verificación de tipos falla), se reescribe de acuerdo con las siguientes reglas:
foo.method("blah") ~~> foo.applyDynamic("method")("blah")
foo.method(x = "blah") ~~> foo.applyDynamicNamed("method")(("x", "blah"))
foo.method(x = 1, 2) ~~> foo.applyDynamicNamed("method")(("x", 1), ("", 2))
foo.field ~~> foo.selectDynamic("field")
foo.varia = 10 ~~> foo.updateDynamic("varia")(10)
foo.arr(10) = 13 ~~> foo.selectDynamic("arr").update(10, 13)
foo.arr(10) ~~> foo.applyDynamic("arr")(10)
Scala tiene los mismos tipos de datos que Java, con la misma huella de memoria y precisión. A continuación se muestra la tabla que brinda detalles sobre todos los tipos de datos disponibles en Scala:
No Señor | Tipo de datos y descripción |
---|---|
1 | Byte Valor con signo de 8 bits. Rango de -128 a 127 |
2 | Short Valor con signo de 16 bits. Rango -32768 a 32767 |
3 | Int Valor con signo de 32 bits. Rango -2147483648 a 2147483647 |
4 | Long Valor con signo de 64 bits. -9223372036854775808 al 9223372036854775807 |
5 | Float Flotador de precisión simple IEEE 754 de 32 bits |
6 | Double Flotador de doble precisión IEEE 754 de 64 bits |
7 | Char Carácter Unicode sin firmar de 16 bits. Rango de U + 0000 a U + FFFF |
8 | String Una secuencia de caracteres |
9 | Boolean O lo literal verdadero o lo literal falso |
10 | Unit Corresponde a ningún valor |
11 | Null referencia nula o vacía |
12 | Nothing El subtipo de cualquier otro tipo; no incluye valores |
13 | Any El supertipo de cualquier tipo; cualquier objeto es de tipo Cualquiera |
14 | AnyRef El supertipo de cualquier tipo de referencia |
Todos los tipos de datos enumerados anteriormente son objetos. No hay tipos primitivos como en Java. Esto significa que puede llamar a métodos en un Int, Long, etc.
Literales básicos de Scala
Las reglas que utiliza Scala para literales son simples e intuitivas. Esta sección explica todos los Literales Scala básicos.
Literales integrales
Los literales enteros suelen ser de tipo Int, o de tipo Long cuando van seguidos de un sufijo L o l. Aquí hay algunos literales enteros:
0
035
21
0xFFFFFFFF
0777L
Literal de coma flotante
Los literales de coma flotante son de tipo Float cuando van seguidos de un sufijo de tipo de coma flotante F o f, y son de tipo Double en caso contrario. Aquí hay algunos literales de punto flotante:
0.0
1e30f
3.14159f
1.0e100
.1
Literales booleanos
Los literales booleanos true y false son miembros de tipo booleano.
Literales de símbolos
Un símbolo literal 'x es una abreviatura de la expresión scala.Symbol("x"). El símbolo es una clase de caso, que se define de la siguiente manera.
package scala
final case class Symbol private (name: String) {
override def toString: String = "'" + name
}
Literales de caracteres
Un carácter literal es un solo carácter entre comillas. El carácter es un carácter Unicode imprimible o se describe mediante una secuencia de escape. Aquí hay algunos caracteres literales:
'a'
'\u0041'
'\n'
'\t'
Literales de cadena
Un literal de cadena es una secuencia de caracteres entre comillas dobles. Los caracteres son caracteres Unicode imprimibles o se describen mediante secuencias de escape. Aquí hay algunos literales de cadena:
"Hello,\nWorld!"
"This string contains a \" character."
Cuerdas de varias líneas
Un literal de cadena de varias líneas es una secuencia de caracteres entre comillas triples "" "..." "". La secuencia de caracteres es arbitraria, excepto que puede contener tres o más caracteres de comillas consecutivas solo al final.
Los caracteres no deben ser necesariamente imprimibles; También se permiten nuevas líneas u otros caracteres de control. Aquí hay un literal de cadena de varias líneas:
"""the present string
spans three
lines."""
Valores nulos
El valor nulo es de tipo scala.Nullpor lo que es compatible con todos los tipos de referencia. Denota un valor de referencia que se refiere a un objeto especial "nulo".
Secuencias de escape
Las siguientes secuencias de escape se reconocen en literales de caracteres y cadenas.
Secuencias de escape | Unicode | Descripción |
---|---|---|
\segundo | \ u0008 | retroceso BS |
\ t | \ u0009 | pestaña horizontal HT |
\norte | \ u000c | formfeed FF |
\F | \ u000c | formfeed FF |
\ r | \ u000d | retorno de carro CR |
\ " | \ u0022 | comillas dobles " |
\ ' | \ u0027 | una frase . |
\\ | \ u005c | barra invertida \ |
Un carácter con Unicode entre 0 y 255 también puede estar representado por un escape octal, es decir, una barra invertida '\' seguida de una secuencia de hasta tres caracteres octales. A continuación se muestra el ejemplo para mostrar algunos caracteres de secuencia de escape:
Ejemplo
object Test {
def main(args: Array[String]) {
println("Hello\tWorld\n\n" );
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
Salida
Hello World
Las variables no son más que ubicaciones de memoria reservadas para almacenar valores. Esto significa que cuando crea una variable, reserva algo de espacio en la memoria.
Según el tipo de datos de una variable, el compilador asigna memoria y decide qué se puede almacenar en la memoria reservada. Por lo tanto, al asignar diferentes tipos de datos a las variables, puede almacenar números enteros, decimales o caracteres en estas variables.
Declaración de variable
Scala tiene una sintaxis diferente para declarar variables. Se pueden definir como valor, es decir, constante o variable. Aquí, myVar se declara usando la palabra clave var. Es una variable que puede cambiar de valor y esto se llamamutable variable. A continuación se muestra la sintaxis para definir una variable usandovar palabra clave -
Sintaxis
var myVar : String = "Foo"
Aquí, myVal se declara utilizando la palabra clave val. Esto significa que es una variable que no se puede cambiar y se llamaimmutable variable. A continuación se muestra la sintaxis para definir una variable usando la palabra clave val:
Sintaxis
val myVal : String = "Foo"
Tipos de datos variables
El tipo de variable se especifica después del nombre de la variable y antes del signo igual. Puede definir cualquier tipo de variable Scala mencionando su tipo de datos de la siguiente manera:
Sintaxis
val or val VariableName : DataType = [Initial Value]
Si no asigna ningún valor inicial a una variable, entonces es válido de la siguiente manera:
Sintaxis
var myVar :Int;
val myVal :String;
Inferencia de tipo variable
Cuando asigna un valor inicial a una variable, el compilador de Scala puede averiguar el tipo de variable en función del valor que se le asigna. Esto se llama inferencia de tipo variable. Por lo tanto, podría escribir estas declaraciones de variables como esta:
Sintaxis
var myVar = 10;
val myVal = "Hello, Scala!";
Aquí, de forma predeterminada, myVar será de tipo Int y myVal se convertirá en una variable de tipo String.
Varias asignaciones
Scala admite múltiples asignaciones. Si un bloque de código o método devuelve una Tupla (Tuple- Contiene una colección de objetos de diferentes tipos), la tupla se puede asignar a una variable val. [Note - Estudiaremos las tuplas en capítulos posteriores.]
Sintaxis
val (myVar1: Int, myVar2: String) = Pair(40, "Foo")
Y la inferencia de tipos lo hace bien:
Sintaxis
val (myVar1, myVar2) = Pair(40, "Foo")
Programa de ejemplo
El siguiente es un programa de ejemplo que explica el proceso de declaración de variables en Scala. Este programa declara cuatro variables: dos variables se definen con declaración de tipo y las dos restantes sin declaración de tipo.
Ejemplo
object Demo {
def main(args: Array[String]) {
var myVar :Int = 10;
val myVal :String = "Hello Scala with datatype declaration.";
var myVar1 = 20;
val myVal1 = "Hello Scala new without datatype declaration.";
println(myVar); println(myVal); println(myVar1);
println(myVal1);
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
10
Hello Scala with datatype declaration.
20
Hello Scala without datatype declaration.
Alcance variable
Las variables en Scala pueden tener tres ámbitos diferentes según el lugar donde se estén utilizando. Pueden existir como campos, como parámetros de método y como variables locales. A continuación se muestran los detalles sobre cada tipo de alcance.
Campos
Los campos son variables que pertenecen a un objeto. Los campos son accesibles desde el interior de todos los métodos del objeto. Los campos también pueden ser accesibles fuera del objeto dependiendo de los modificadores de acceso con los que se declare el campo. Los campos de objeto pueden ser de tipo mutable e inmutable y se pueden definir utilizandovar o val.
Parámetros del método
Los parámetros de método son variables, que se utilizan para pasar el valor dentro de un método, cuando se llama al método. Los parámetros del método solo son accesibles desde el interior del método, pero los objetos pasados pueden ser accesibles desde el exterior, si tiene una referencia al objeto desde fuera del método. Los parámetros del método son siempre inmutables y están definidos porval palabra clave.
Variables locales
Las variables locales son variables declaradas dentro de un método. Las variables locales solo son accesibles desde dentro del método, pero los objetos que crea pueden escapar del método si los devuelve desde el método. Las variables locales pueden ser de tipo mutable e inmutable y se pueden definir utilizandovar o val.
Este capítulo le explica cómo utilizar clases y objetos en la programación de Scala. Una clase es un plano de objetos. Una vez que define una clase, puede crear objetos a partir del plano de la clase con la palabra clavenew. A través del objeto puede utilizar todas las funcionalidades de la clase definida.
El siguiente diagrama muestra la clase y el objeto tomando un ejemplo de clase estudiante, que contiene las variables miembro (nombre y número de rollo) y los métodos miembros (setName () y setRollNo ()). Finalmente todos son miembros de la clase. La clase es un plano y los objetos son reales aquí. En el siguiente diagrama, Student es una clase y Harini, John y Maria son los objetos de la clase Student, que tienen nombre y número de rollo.
Clase básica
A continuación se muestra una sintaxis simple para definir una clase básica en Scala. Esta clase define dos variablesx y y y un método: move, que no devuelve un valor. Las variables de clase se llaman, los campos de la clase y los métodos se denominan métodos de clase.
El nombre de la clase funciona como un constructor de clases que puede tomar varios parámetros. El código anterior define dos argumentos de constructor,xc y yc; ambos son visibles en todo el cuerpo de la clase.
Sintaxis
class Point(xc: Int, 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);
}
}
Como se mencionó anteriormente en este capítulo, puede crear objetos usando una palabra clave new y luego puede acceder a los campos y métodos de la clase como se muestra a continuación en el ejemplo:
Ejemplo
import java.io._
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);
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Point x location : 20
Point y location : 30
Ampliando una clase
Puede extender una clase base de Scala y puede diseñar una clase heredada de la misma manera que lo hace en Java (use extends palabra clave), pero hay dos restricciones: la invalidación del método requiere la override palabra clave, y solo la primaryEl constructor puede pasar parámetros al constructor base. Extendamos nuestra clase anterior y agreguemos un método de clase más.
Ejemplo
Tomemos un ejemplo de dos clases, la clase Point (como el mismo ejemplo anterior) y la clase Location es una clase heredada usando la palabra clave extendida. Tal 'extends'tiene dos efectos: hace que la clase Location herede todos los miembros no privados de la clase Point y hace que el tipo Location sea un subtipo del tipo clase Point . Entonces aquí la clase Point se llamasuperclassy la clase Location se llamasubclass. Extender una clase y heredar todas las características de una clase padre se llamainheritance pero Scala permite la herencia de una sola clase.
Note - Métodos método move () en la clase Point y move() method in Location class no anule las definiciones correspondientes de movimiento ya que son definiciones diferentes (por ejemplo, la primera toma dos argumentos mientras que la última toma tres argumentos).
Pruebe el siguiente programa de ejemplo para implementar la herencia.
import java.io._
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);
}
}
class Location(override val xc: Int, override val yc: Int,
val zc :Int) extends Point(xc, yc){
var z: Int = zc
def move(dx: Int, dy: Int, dz: Int) {
x = x + dx
y = y + dy
z = z + dz
println ("Point x location : " + x);
println ("Point y location : " + y);
println ("Point z location : " + z);
}
}
object Demo {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// Move to a new location
loc.move(10, 10, 5);
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Point x location : 20
Point y location : 30
Point z location : 20
Clases implícitas
Las clases implícitas permiten conversaciones implícitas con el constructor principal de la clase cuando la clase está dentro del alcance. La clase implícita es una clase marcada con la palabra clave "implícita". Esta característica se introduce en Scala 2.10.
Syntax- La siguiente es la sintaxis para clases implícitas. Aquí la clase implícita siempre está en el alcance del objeto donde se permiten todas las definiciones de método porque la clase implícita no puede ser una clase de nivel superior.
Sintaxis
object <object name> {
implicit class <class name>(<Variable>: Data type) {
def <method>(): Unit =
}
}
Ejemplo
Tomemos un ejemplo de una clase implícita llamada IntTimescon el método times (). Significa que times () contienen una transacción de bucle que ejecutará la declaración dada en el número de veces que damos. Supongamos que la declaración dada es “4 veces println (“ Hola ”)” significa que la declaración println (“” Hola ”) se ejecutará 4 veces.
El siguiente es el programa para el ejemplo dado. En este ejemplo se utilizan dos clases de objetos (Ejecutar y Demo) de modo que tenemos que guardar esas dos clases en archivos diferentes con sus respectivos nombres de la siguiente manera.
Run.scala - Guarde el siguiente programa en Run.scala.
object Run {
implicit class IntTimes(x: Int) {
def times [A](f: =>A): Unit = {
def loop(current: Int): Unit =
if(current > 0){
f
loop(current - 1)
}
loop(x)
}
}
}
Demo.scala - Guarde el siguiente programa en Demo.scala.
import Run._
object Demo {
def main(args: Array[String]) {
4 times println("hello")
}
}
Los siguientes comandos se utilizan para compilar y ejecutar estos dos programas.
Mando
\>scalac Run.scala
\>scalac Demo.scala
\>scala Demo
Salida
Hello
Hello
Hello
Hello
Note -
Las clases implícitas deben definirse dentro de otra clase / objeto / rasgo (no en el nivel superior).
Las clases implícitas solo pueden tomar un argumento no implícito en su constructor.
Las clases implícitas no pueden ser ningún método, miembro u objeto dentro del alcance con el mismo nombre que la clase implícita.
Objetos Singleton
Scala está más orientado a objetos que Java porque en Scala no podemos tener miembros estáticos. En cambio, Scala tienesingleton objects. Un singleton es una clase que solo puede tener una instancia, es decir, Object. Creas singleton usando la palabra claveobjecten lugar de la palabra clave de clase. Dado que no puede crear una instancia de un objeto singleton, no puede pasar parámetros al constructor principal. Ya ha visto todos los ejemplos usando objetos singleton donde llamó al método principal de Scala.
A continuación se muestra el mismo programa de ejemplo para implementar singleton.
Ejemplo
import java.io._
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
}
}
object Demo {
def main(args: Array[String]) {
val point = new Point(10, 20)
printPoint
def printPoint{
println ("Point x location : " + point.x);
println ("Point y location : " + point.y);
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Point x location : 10
Point y location : 20
Este capítulo lo lleva a través de los modificadores de acceso de Scala. Los miembros de paquetes, clases u objetos pueden etiquetarse con los modificadores de acceso como privado y protegido, y si no usamos ninguna de estas dos palabras clave, el acceso se asumirá como público. Estos modificadores restringen el acceso de los miembros a ciertas regiones de código. Para usar un modificador de acceso, incluya su palabra clave en la definición de miembros de paquete, clase u objeto como veremos en la siguiente sección.
Miembros privados
Un miembro privado es visible solo dentro de la clase u objeto que contiene la definición del miembro.
A continuación se muestra el fragmento de código de ejemplo para explicar el miembro privado:
Ejemplo
class Outer {
class Inner {
private def f() { println("f") }
class InnerMost {
f() // OK
}
}
(new Inner).f() // Error: f is not accessible
}
En Scala, el acceso (nuevo Inner). f () es ilegal porque f se declara privada en Inner y el acceso no es desde dentro de la clase Inner. Por el contrario, el primer acceso af en la clase Innermost está bien, porque ese acceso está contenido en el cuerpo de la clase Inner. Java permitiría ambos accesos porque permite que una clase externa acceda a miembros privados de sus clases internas.
Miembros protegidos
Un miembro protegido solo es accesible desde las subclases de la clase en la que está definido el miembro.
A continuación se muestra el fragmento de código de ejemplo para explicar el miembro protegido:
Ejemplo
package p {
class Super {
protected def f() { println("f") }
}
class Sub extends Super {
f()
}
class Other {
(new Super).f() // Error: f is not accessible
}
}
El acceso af en la clase Sub está bien porque f se declara protegido en la clase 'Super' y la clase 'Sub' es una subclase de Super. Por el contrario, el acceso af en la clase 'Otro' no está permitido, porque la clase 'Otro' no hereda de la clase 'Super'. En Java, el último acceso todavía estaría permitido porque la clase 'Otro' está en el mismo paquete que la clase 'Sub'.
Miembros públicos
A diferencia de los miembros privados y protegidos, no es necesario especificar la palabra clave pública para los miembros públicos. No hay un modificador explícito para los miembros públicos. Se puede acceder a estos miembros desde cualquier lugar.
A continuación se muestra el fragmento de código de ejemplo para explicar el miembro público:
Ejemplo
class Outer {
class Inner {
def f() { println("f") }
class InnerMost {
f() // OK
}
}
(new Inner).f() // OK because now f() is public
}
Alcance de la protección
Los modificadores de acceso en Scala se pueden aumentar con calificadores. Un modificador de la forma privado [X] o protegido [X] significa que el acceso es privado o protegido "hasta" X, donde X designa algún paquete, clase u objeto singleton adjunto.
Considere el siguiente ejemplo:
Ejemplo
package 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
}
}
}
}
Note - los siguientes puntos del ejemplo anterior -
WorkDetails variables serán accesibles para cualquier clase dentro del paquete adjunto profesional.
Los amigos variables estarán disponibles para cualquier clase dentro de la sociedad del paquete adjunto.
Los secretos de las variables serán accesibles solo en el objeto implícito dentro de los métodos de instancia (this).
Un operador es un símbolo que le dice al compilador que realice manipulaciones matemáticas o lógicas específicas. Scala es rico en operadores integrados y proporciona los siguientes tipos de operadores:
- Operadores aritméticos
- Operadores relacionales
- Operadores logicos
- Operadores bit a bit
- Operadores de Asignación
Este capítulo examinará los operadores aritméticos, relacionales, lógicos, bit a bit, de asignación y otros, uno por uno.
Operadores aritméticos
Los siguientes operadores aritméticos son compatibles con el lenguaje Scala. Por ejemplo, supongamos que la variable A tiene 10 y la variable B tiene 20, entonces -
Mostrar ejemplos
Operador | Descripción | Ejemplo |
---|---|---|
+ | Agrega dos operandos | A + B dará 30 |
- | Resta el segundo operando del primero | A - B dará -10 |
* | Multiplica ambos operandos | A * B dará 200 |
/ | Divide el numerador por el numerador | B / A dará 2 |
% | El operador de módulo encuentra el resto después de la división de un número por otro | B % A will give 0 |
Relational Operators
The following relational operators are supported by Scala language. For example let us assume variable A holds 10 and variable B holds 20, then −
Show Examples
Operator | Description | Example |
---|---|---|
== | Checks if the values of two operands are equal or not, if yes then condition becomes true. | (A == B) is not true. |
!= | Checks if the values of two operands are equal or not, if values are not equal then condition becomes true. | (A != B) is true. |
> | Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true. | (A > B) is not true. |
< | Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true. | (A < B) is true. |
>= | Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true. | (A >= B) is not true. |
<= | Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true. | (A <= B) is true. |
Logical Operators
The following logical operators are supported by Scala language. For example, assume variable A holds 1 and variable B holds 0, then −
Show Examples
Operator | Description | Example |
---|---|---|
&& | It is called Logical AND operator. If both the operands are non zero then condition becomes true. | (A && B) is false. |
|| | It is called Logical OR Operator. If any of the two operands is non zero then condition becomes true. | (A || B) is true. |
! | It is called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. | !(A && B) is true. |
Bitwise Operators
Bitwise operator works on bits and perform bit by bit operation. The truth tables for &, |, and ^ are as follows −
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
Assume if A = 60; and B = 13; now in binary format they will be as follows −
A = 0011 1100
B = 0000 1101
-----------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
The Bitwise operators supported by Scala language is listed in the following table. Assume variable A holds 60 and variable B holds 13, then −
Show Examples
Operator | Description | Example |
---|---|---|
& | Binary AND Operator copies a bit to the result if it exists in both operands. | (A & B) will give 12, which is 0000 1100 |
| | Binary OR Operator copies a bit if it exists in either operand. | (A | B) will give 61, which is 0011 1101 |
^ | Binary XOR Operator copies the bit if it is set in one operand but not both. | (A ^ B) will give 49, which is 0011 0001 |
~ | Binary Ones Complement Operator is unary and has the effect of 'flipping' bits. | (~A ) will give -61, which is 1100 0011 in 2's complement form due to a signed binary number. |
<< | Binary Left Shift Operator. The bit positions of the left operands value is moved left by the number of bits specified by the right operand. | A << 2 will give 240, which is 1111 0000 |
>> | Binary Right Shift Operator. The Bit positions of the left operand value is moved right by the number of bits specified by the right operand. | A >> 2 will give 15, which is 1111 |
>>> | Shift right zero fill operator. The left operands value is moved right by the number of bits specified by the right operand and shifted values are filled up with zeros. | A >>>2 will give 15 which is 0000 1111 |
Assignment Operators
There are following assignment operators supported by Scala language −
Show Examples
Operator | Description | Example |
---|---|---|
= | Simple assignment operator, Assigns values from right side operands to left side operand | C = A + B will assign value of A + B into C |
+= | Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand | C += A is equivalent to C = C + A |
-= | Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand | C -= A is equivalent to C = C - A |
*= | Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand | C *= A is equivalent to C = C * A |
/= | Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand | C /= A is equivalent to C = C / A |
%= | Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand | C %= A is equivalent to C = C % A |
<<= | Left shift AND assignment operator | C <<= 2 is same as C = C << 2 |
>>= | Right shift AND assignment operator | C >>= 2 is same as C = C >> 2 |
&= | Bitwise AND assignment operator | C &= 2 is same as C = C & 2 |
^= | bitwise exclusive OR and assignment operator | C ^= 2 is same as C = C ^ 2 |
|= | bitwise inclusive OR and assignment operator | C |= 2 is same as C = C | 2 |
Precedencia de operadores en Scala
La precedencia del operador determina la agrupación de términos en una expresión. Esto afecta cómo se evalúa una expresión. Ciertos operadores tienen mayor precedencia que otros; por ejemplo, el operador de multiplicación tiene mayor precedencia que el operador de suma -
Por ejemplo, x = 7 + 3 * 2; aquí, a x se le asigna 13, no 20 porque el operador * tiene mayor precedencia que +, por lo que primero se multiplica por 3 * 2 y luego se suma a 7.
Eche un vistazo a la siguiente tabla. Los operadores con la precedencia más alta aparecen en la parte superior de la tabla y los que tienen la precedencia más baja aparecen en la parte inferior. Dentro de una expresión, los operadores de mayor precedencia se evaluarán primero.
Categoría | Operador | Asociatividad |
---|---|---|
Sufijo | () [] | De izquierda a derecha |
Unario | ! ~ | De derecha a izquierda |
Multiplicativo | * /% | De izquierda a derecha |
Aditivo | + - | De izquierda a derecha |
Cambio | >> >>> << | De izquierda a derecha |
Relacional | >> = <<= | De izquierda a derecha |
Igualdad | ==! = | De izquierda a derecha |
Y bit a bit | Y | De izquierda a derecha |
XOR bit a bit | ^ | De izquierda a derecha |
O bit a bit | | | De izquierda a derecha |
Y lógico | && | De izquierda a derecha |
OR lógico | || | De izquierda a derecha |
Asignación | = + = - = * = / =% = >> = << = & = ^ = | = | De derecha a izquierda |
Coma | , | De izquierda a derecha |
Este capítulo lo lleva a través de las declaraciones de construcción condicional en la programación de Scala. A continuación se muestra la forma general de una estructura típica de toma de decisiones IF ... ELSE que se encuentra en la mayoría de los lenguajes de programación.
Diagrama de flujo
El siguiente es un diagrama de flujo para la declaración condicional.
si declaración
La declaración 'if' consiste en una expresión booleana seguida de una o más declaraciones.
Sintaxis
La sintaxis de una instrucción 'if' es la siguiente.
if(Boolean_expression) {
// Statements will execute if the Boolean expression is true
}
Si la expresión booleana se evalúa como verdadera, se ejecutará el bloque de código dentro de la expresión 'if'. De lo contrario, se ejecutará el primer conjunto de código después del final de la expresión 'if' (después de la llave de cierre).
Pruebe el siguiente programa de ejemplo para comprender las expresiones condicionales (si expresión) en el lenguaje de programación Scala.
Ejemplo
object Demo {
def main(args: Array[String]) {
var x = 10;
if( x < 20 ){
println("This is if statement");
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
This is if statement
Declaración If-else
Una instrucción 'if' puede ir seguida de una instrucción else opcional , que se ejecuta cuando la expresión booleana es falsa.
Sintaxis
La sintaxis de un if ... else es -
if(Boolean_expression){
//Executes when the Boolean expression is true
} else{
//Executes when the Boolean expression is false
}
Pruebe el siguiente programa de ejemplo para comprender las declaraciones condicionales (instrucción if-else) en el lenguaje de programación Scala.
Ejemplo
object Demo {
def main(args: Array[String]) {
var x = 30;
if( x < 20 ){
println("This is if statement");
} else {
println("This is else statement");
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
This is else statement
Declaración if-else-if-else
Una instrucción 'if' puede ir seguida de una instrucción opcional ' else if ... else ', que es muy útil para probar varias condiciones usando una instrucción if ... else if.
Al usar declaraciones if, else if, else, hay algunos puntos a tener en cuenta.
Un 'si' puede tener cero o uno más y debe ir después de cualquier otro si.
Un 'si' puede tener de cero a muchos otros si y deben ir antes que los demás.
Una vez que un else if tiene éxito, no se probará ninguno de los demás if o else.
Sintaxis
La siguiente es la sintaxis de un 'if ... else if ... else' es la siguiente:
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.
}
Pruebe el siguiente programa de ejemplo para comprender las declaraciones condicionales (instrucción if-else-if-else) en el lenguaje de programación Scala.
Ejemplo
object Demo {
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");
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Value of X is 30
Declaración if-else anidada
Siempre es legal anidar if-else declaraciones, lo que significa que puede usar una if o else-if declaración dentro de otra if o else-if declaración.
Sintaxis
La sintaxis de un if-else anidado es la siguiente:
if(Boolean_expression 1){
//Executes when the Boolean expression 1 is true
if(Boolean_expression 2){
//Executes when the Boolean expression 2 is true
}
}
Pruebe el siguiente programa de ejemplo para comprender las declaraciones condicionales (instrucción if anidada) en el lenguaje de programación Scala.
Ejemplo
object Demo {
def main(args: Array[String]) {
var x = 30;
var y = 10;
if( x == 30 ){
if( y == 10 ){
println("X = 30 and Y = 10");
}
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
X = 30 and Y = 10
Este capítulo lo lleva a través de las estructuras de control de bucle en los lenguajes de programación Scala.
Puede haber una situación en la que necesite ejecutar un bloque de código varias veces. En general, las sentencias se ejecutan secuencialmente: la primera sentencia de una función se ejecuta primero, seguida de la segunda, y así sucesivamente.
Los lenguajes de programación proporcionan varias estructuras de control que permiten rutas de ejecución más complicadas.
Una declaración de bucle nos permite ejecutar una declaración o grupo de declaraciones varias veces y la siguiente es la forma general de una declaración de bucle en la mayoría de los lenguajes de programación:
Diagrama de flujo
El lenguaje de programación Scala proporciona los siguientes tipos de bucles para manejar los requisitos de bucles. Haga clic en los siguientes enlaces de la tabla para comprobar su detalle.
No Señor | Tipo de bucle y descripción |
---|---|
1 | while loop Repite una declaración o un grupo de declaraciones mientras una condición determinada es verdadera. Prueba la condición antes de ejecutar el cuerpo del bucle. |
2 | do-while loop Como una instrucción while, excepto que prueba la condición al final del cuerpo del bucle. |
3 | for loop Ejecuta una secuencia de declaraciones varias veces y abrevia el código que administra la variable de ciclo. |
Declaraciones de control de bucle
Las sentencias de control de bucle cambian la ejecución de su secuencia normal. Cuando la ejecución abandona un ámbito, todos los objetos automáticos que se crearon en ese ámbito se destruyen. Como tal, Scala no admitebreak o continuedeclaración como lo hace Java, pero a partir de la versión 2.8 de Scala, hay una manera de romper los bucles. Haga clic en los siguientes enlaces para verificar el detalle.
No Señor | Declaración de control y descripción |
---|---|
1 | break statement Termina el loop instrucción y transfiere la ejecución a la instrucción que sigue inmediatamente al ciclo. |
El bucle infinito
Un bucle se convierte en un bucle infinito si una condición nunca se vuelve falsa. Si está utilizando Scala, elwhile loop es la mejor manera de implementar un bucle infinito.
El siguiente programa implementa un bucle infinito.
Ejemplo
object Demo {
def main(args: Array[String]) {
var a = 10;
// An infinite loop.
while( true ){
println( "Value of a: " + a );
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Si va a ejecutar el código anterior, irá en un bucle infinito que puede terminar presionando las teclas Ctrl + C.
Value of a: 10
Value of a: 10
Value of a: 10
Value of a: 10
…………….
Una función es un grupo de declaraciones que realizan una tarea. Puede dividir su código en funciones separadas. La forma en que divide su código entre las diferentes funciones depende de usted, pero lógicamente, la división generalmente es para que cada función realice una tarea específica.
Scala tiene funciones y métodos y usamos los términos método y función indistintamente con una pequeña diferencia. Un método de Scala es una parte de una clase que tiene un nombre, una firma, opcionalmente algunas anotaciones y algún código de bytes donde, como 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 método.
Una definición de función puede aparecer en cualquier lugar de un archivo fuente y Scala permite definiciones de funciones anidadas, es decir, definiciones de funciones dentro de otras definiciones de funciones. El punto más importante a tener en cuenta es que el nombre de la función Scala puede tener caracteres como +, ++, ~, &, -, -, \, /,:, etc.
Declaraciones de funciones
Una declaración de función de Scala tiene la siguiente forma:
def functionName ([list of parameters]) : [return type]
Los métodos se declaran implícitamente abstractos si no usa el signo igual y el cuerpo del método.
Definiciones de funciones
Una definición de función de Scala tiene la siguiente forma:
Sintaxis
def functionName ([list of parameters]) : [return type] = {
function body
return [expr]
}
Aquí, return type podría ser cualquier tipo de datos Scala válido y list of parametersserá una lista de variables separadas por comas y la lista de parámetros y el tipo de retorno son opcionales. Muy similar a Java, unreturnLa declaración se puede usar junto con una expresión en caso de que la función devuelva un valor. A continuación se muestra la función que sumará dos enteros y devolverá su suma:
Sintaxis
object add {
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
Una función que no devuelve nada puede devolver un Unit que es equivalente a voiden Java e indica que la función no devuelve nada. Las funciones que no devuelven nada en Scala se denominan procedimientos.
Sintaxis
Aquí está la sintaxis:
object Hello{
def printMe( ) : Unit = {
println("Hello, Scala!")
}
}
Funciones de llamada
Scala proporciona una serie de variaciones sintácticas para invocar métodos. A continuación se muestra la forma estándar de llamar a un método:
functionName( list of parameters )
Si se llama a una función usando una instancia del objeto, entonces usaríamos notación de puntos similar a Java de la siguiente manera:
[instance.]functionName( list of parameters )
Pruebe el siguiente programa de ejemplo para definir y luego llame a la misma función.
Ejemplo
object Demo {
def main(args: Array[String]) {
println( "Returned Value : " + addInt(5,7) );
}
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Returned Value : 12
Las funciones de Scala son el corazón de la programación de Scala y por eso se asume que Scala es un lenguaje de programación funcional. A continuación se presentan algunos conceptos importantes relacionados con las funciones de Scala que un programador de Scala debería comprender.
Funciones llamada por nombre | Funciones con argumentos con nombre |
Función con argumentos variables | Funciones de recursividad |
Valores de parámetros predeterminados | Funciones de orden superior |
Funciones anidadas | Funciones anónimas |
Funciones parcialmente aplicadas | Funciones de curry |
UN closure es una función, cuyo valor de retorno depende del valor de una o más variables declaradas fuera de esta función.
El siguiente fragmento de código con función anónima.
val multiplier = (i:Int) => i * 10
Aquí, la única variable utilizada en el cuerpo de la función, i * 10, es i, que se define como un parámetro de la función. Prueba el siguiente código:
val multiplier = (i:Int) => i * factor
Hay dos variables libres en multiplicador: i y factor. Uno de ellos, i, es un parámetro formal de la función. Por lo tanto, está vinculado a un nuevo valor cada vez que se llama al multiplicador. Sin embargo,factorno es un parámetro formal, entonces ¿qué es esto? Agreguemos una línea más de código.
var factor = 3
val multiplier = (i:Int) => i * factor
Ahora factortiene una referencia a una variable fuera de la función pero en el ámbito adjunto. La función hace referenciafactory lee su valor actual cada vez. Si una función no tiene referencias externas, entonces se cierra trivialmente sobre sí misma. No se requiere contexto externo.
Pruebe el siguiente programa de ejemplo.
Ejemplo
object Demo {
def main(args: Array[String]) {
println( "multiplier(1) value = " + multiplier(1) )
println( "multiplier(2) value = " + multiplier(2) )
}
var factor = 3
val multiplier = (i:Int) => i * factor
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
multiplier(1) value = 3
multiplier(2) value = 6
Este capítulo lo lleva a través de Scala Strings. En Scala, como en Java, una cadena es un objeto inmutable, es decir, un objeto que no se puede modificar. Por otro lado, los objetos que se pueden modificar, como las matrices, se denominan objetos mutables. Las cadenas son objetos muy útiles, en el resto de esta sección, presentamos métodos importantes dejava.lang.String clase.
Crear una cadena
El siguiente código se puede utilizar para crear una cadena:
var greeting = "Hello world!";
or
var greeting:String = "Hello world!";
Siempre que el compilador encuentra un literal de cadena en el código, crea un objeto String con su valor, en este caso, "¡Hola mundo!". La palabra clave de cadena también se puede dar en una declaración alternativa como se muestra arriba.
Pruebe el siguiente programa de ejemplo.
Ejemplo
object Demo {
val greeting: String = "Hello, world!"
def main(args: Array[String]) {
println( greeting )
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Hello, world!
Como se mencionó anteriormente, la clase String es inmutable. El objeto de cadena una vez creado no se puede cambiar. Si es necesario realizar muchas modificaciones en las cadenas de caracteres, utilice la clase String Builder disponible en Scala.
Longitud de la cuerda
Los métodos utilizados para obtener información sobre un objeto se conocen como métodos de acceso. Un método de acceso que se puede usar con cadenas es el método length (), que devuelve el número de caracteres contenidos en el objeto de cadena.
Utilice el siguiente segmento de código para encontrar la longitud de una cadena:
Ejemplo
object Demo {
def main(args: Array[String]) {
var palindrome = "Dot saw I was Tod";
var len = palindrome.length();
println( "String Length is : " + len );
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
String Length is : 17
Concatenación de cadenas
La clase String incluye un método para concatenar dos cadenas:
string1.concat(string2);
Esto devuelve una nueva cadena que es cadena1 con cadena2 agregada al final. También puede usar el método concat () con cadenas literales, como en -
"My name is ".concat("Zara");
Las cadenas se concatenan más comúnmente con el operador +, como en -
"Hello," + " world" + "!"
Lo que resulta en -
"Hello, world!"
Las siguientes líneas de código para encontrar la longitud de la cadena.
Ejemplo
object Demo {
def main(args: Array[String]) {
var str1 = "Dot saw I was ";
var str2 = "Tod";
println("Dot " + str1 + str2);
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Dot Dot saw I was Tod
Crear cadenas de formato
Tiene métodos printf () y format () para imprimir resultados con números formateados. La clase String tiene un método de clase equivalente, format (), que devuelve un objeto String en lugar de un objeto PrintStream.
Pruebe el siguiente programa de ejemplo, que utiliza el método printf ():
Ejemplo
object Demo {
def main(args: Array[String]) {
var floatVar = 12.456
var intVar = 2000
var stringVar = "Hello, Scala!"
var fs = printf("The value of the float variable is " + "%f, while the value of the integer " + "variable is %d, and the string" + "is %s", floatVar, intVar, stringVar);
println(fs)
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
mando
\>scalac Demo.scala
\>scala Demo
Salida
The value of the float variable is 12.456000,
while the value of the integer variable is 2000,
and the string is Hello, Scala!()
Interpolación de cadenas
La interpolación de cadenas es la nueva forma de crear cadenas en el lenguaje de programación Scala. Esta función es compatible con las versiones de Scala-2.10 y posteriores. Interpolación de cadenas: mecanismo para incrustar referencias de variables directamente en el literal de cadena de proceso.
Hay tres tipos (interpoladores) de implementaciones en String Interpolation.
El interpolador de cadenas 's'
El literal 's' permite el uso de la variable directamente al procesar una cadena, cuando le antepone 's'. Cualquier variable de cadena dentro de un alcance que se pueda usar en una cadena. Los siguientes son los diferentes usos del interpolador de cadenas 's'.
El siguiente fragmento de código de ejemplo para la implementación del interpolador 's' al agregar la variable String ($ name) a una String normal (Hello) en la declaración println.
val name = “James”
println(s “Hello, $name”) //output: Hello, James
El interpolador de cadenas también puede procesar expresiones arbitrarias. El siguiente fragmento de código para procesar una cadena (1 + 1) con una expresión arbitraria ($ {1 + 1}) utilizando el interpolador de cadenas 's'. Cualquier expresión arbitraria se puede incrustar en '$ {}'.
println(s “1 + 1 = ${1 + 1}”) //output: 1 + 1 = 2
Pruebe el siguiente programa de ejemplo de implementación del interpolador 's'.
Ejemplo
object Demo {
def main(args: Array[String]) {
val name = "James"
println(s"Hello, $name") println(s"1 + 1 = ${1 + 1}")
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Hello, James
1 + 1 = 2
El interpolador 'f'
El interpolador literal 'f' permite crear una cadena formateada, similar a printf en lenguaje C. Al usar el interpolador 'f', todas las referencias de variables deben ir seguidas delprintf especificadores de formato de estilo como% d,% i,% f, etc.
Tomemos un ejemplo de agregar un valor de punto flotante (altura = 1.9d) y una variable de cadena (nombre = "James") con una cadena normal. El siguiente fragmento de código de implementación del interpolador 'f'. aquí$name%s to print (String variable) James and $altura% 2.2f para imprimir (valor de punto flotante) 1.90.
val height = 1.9d
val name = "James"
println(f"$name%s is $height%2.2f meters tall") //James is 1.90 meters tall
Es de tipo seguro (es decir,) la referencia de la variable y el siguiente especificador de formato deben coincidir, de lo contrario, muestra un error. El interpolador 'f' hace uso de las utilidades de formato String (especificadores de formato) disponibles en Java. Por defecto, no hay un carácter% después de la referencia de variable. Se asumirá como% s (String).
Interpolador 'crudo'
El interpolador 'crudo' es similar al interpolador 's' excepto que no realiza ningún escape de literales dentro de una cadena. Los siguientes fragmentos de código en una tabla diferirán en el uso de interpoladores 's' y 'raw'. En las salidas del uso de 's', los efectos \ n 'como nueva línea y en la salida del uso' sin procesar ', el' \ n 'no tendrá efecto. Imprimirá la cadena completa con letras de escape.
uso del interpolador 's' | uso del interpolador 'crudo' |
---|---|
Program - |
Program - |
Output - |
Output - |
Métodos de cadena
A continuación se muestra la lista de métodos definidos por java.lang.String class y se puede utilizar directamente en sus programas Scala -
No Señor | Métodos con descripción |
---|---|
1 | char charAt(int index) Devuelve el carácter en el índice especificado. |
2 | int compareTo(Object o) Compara esta cadena con otro objeto. |
3 | int compareTo(String anotherString) Compara dos cadenas lexicográficamente. |
4 | int compareToIgnoreCase(String str) Compara dos cadenas lexicográficamente, ignorando las diferencias entre mayúsculas y minúsculas. |
5 | String concat(String str) Concatena la cadena especificada al final de esta cadena. |
6 | boolean contentEquals(StringBuffer sb) Devuelve verdadero si y solo si esta cadena representa la misma secuencia de caracteres que el StringBuffer especificado. |
7 | static String copyValueOf(char[] data) Devuelve una cadena que representa la secuencia de caracteres en la matriz especificada. |
8 | static String copyValueOf(char[] data, int offset, int count) Devuelve una cadena que representa la secuencia de caracteres en la matriz especificada. |
9 | boolean endsWith(String suffix) Prueba si esta cadena termina con el sufijo especificado. |
10 | boolean equals(Object anObject) Compara esta cadena con el objeto especificado. |
11 | boolean equalsIgnoreCase(String anotherString) Compara esta cadena con otra cadena, ignorando las consideraciones de caso. |
12 | byte getBytes() Codifica esta cadena en una secuencia de bytes utilizando el juego de caracteres predeterminado de la plataforma, almacenando el resultado en una nueva matriz de bytes. |
13 | byte[] getBytes(String charsetName) Codifica esta cadena en una secuencia de bytes usando el conjunto de caracteres con nombre, almacenando el resultado en una nueva matriz de bytes. |
14 | void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) Copia caracteres de esta cadena en la matriz de caracteres de destino. |
15 | int hashCode() Devuelve un código hash para esta cadena. |
dieciséis | int indexOf(int ch) Devuelve el índice dentro de esta cadena de la primera aparición del carácter especificado. |
17 | int indexOf(int ch, int fromIndex) Devuelve el índice dentro de esta cadena de la primera aparición del carácter especificado, comenzando la búsqueda en el índice especificado. |
18 | int indexOf(String str) Devuelve el índice dentro de esta cadena de la primera aparición de la subcadena especificada. |
19 | int indexOf(String str, int fromIndex) Devuelve el índice dentro de esta cadena de la primera aparición de la subcadena especificada, comenzando en el índice especificado. |
20 | String intern() Devuelve una representación canónica del objeto de cadena. |
21 | int lastIndexOf(int ch) Devuelve el índice dentro de esta cadena de la última aparición del carácter especificado. |
22 | int lastIndexOf(int ch, int fromIndex) Devuelve el índice dentro de esta cadena de la última aparición del carácter especificado, buscando hacia atrás comenzando en el índice especificado. |
23 | int lastIndexOf(String str) Devuelve el índice dentro de esta cadena de la aparición más a la derecha de la subcadena especificada. |
24 | int lastIndexOf(String str, int fromIndex) Devuelve el índice dentro de esta cadena de la última aparición de la subcadena especificada, buscando hacia atrás comenzando en el índice especificado. |
25 | int length() Devuelve la longitud de esta cadena. |
26 | boolean matches(String regex) Indica si esta cadena coincide o no con la expresión regular dada. |
27 | boolean regionMatches(boolean ignoreCase, int toffset, String other, int offset, int len) Comprueba si dos regiones de cuerdas son iguales. |
28 | boolean regionMatches(int toffset, String other, int offset, int len) Comprueba si dos regiones de cuerdas son iguales. |
29 | String replace(char oldChar, char newChar) Devuelve una nueva cadena resultante de reemplazar todas las apariciones de oldChar en esta cadena por newChar. |
30 | String replaceAll(String regex, String replacement Reemplaza cada subcadena de esta cadena que coincide con la expresión regular dada con el reemplazo dado. |
31 | String replaceFirst(String regex, String replacement) Reemplaza la primera subcadena de esta cadena que coincide con la expresión regular dada con el reemplazo dado. |
32 | String[] split(String regex) Divide esta cadena entre coincidencias de la expresión regular dada. |
33 | String[] split(String regex, int limit) Divide esta cadena entre coincidencias de la expresión regular dada. |
34 | boolean startsWith(String prefix) Comprueba si esta cadena comienza con el prefijo especificado. |
35 | boolean startsWith(String prefix, int toffset) Comprueba si esta cadena comienza con el prefijo especificado que comienza con un índice especificado. |
36 | CharSequence subSequence(int beginIndex, int endIndex) Devuelve una nueva secuencia de caracteres que es una subsecuencia de esta secuencia. |
37 | String substring(int beginIndex) Devuelve una nueva cadena que es una subcadena de esta cadena. |
38 | String substring(int beginIndex, int endIndex) Devuelve una nueva cadena que es una subcadena de esta cadena. |
39 | char[] toCharArray() Convierte esta cadena en una nueva matriz de caracteres. |
40 | String toLowerCase() Convierte todos los caracteres de esta cadena a minúsculas utilizando las reglas de la configuración regional predeterminada. |
41 | String toLowerCase(Locale locale) Convierte todos los caracteres de esta cadena a minúsculas utilizando las reglas de la configuración regional dada. |
42 | String toString() Este objeto (que ya es una cadena) se devuelve. |
43 | String toUpperCase() Convierte todos los caracteres de esta cadena a mayúsculas utilizando las reglas de la configuración regional predeterminada. |
44 | String toUpperCase(Locale locale) Convierte todos los caracteres de esta cadena en mayúsculas utilizando las reglas de la configuración regional dada. |
45 | String trim() Devuelve una copia de la cadena, omitiendo los espacios en blanco iniciales y finales. |
46 | static String valueOf(primitive data type x) Devuelve la representación de cadena del argumento del tipo de datos pasado. |
Scala proporciona una estructura de datos, la array, que almacena una colección secuencial de tamaño fijo de elementos del mismo tipo. Una matriz se usa para almacenar una colección de datos, pero a menudo es más útil pensar en una matriz como una colección de variables del mismo tipo.
En lugar de declarar variables individuales, como número0, número1, ... y número99, declara una variable de matriz como números y utiliza números [0], números [1] y ..., números [99] para representar variables individuales. Este tutorial presenta cómo declarar variables de matriz, crear matrices y procesar matrices utilizando variables indexadas. El índice del primer elemento de una matriz es el número cero y el índice del último elemento es el número total de elementos menos uno.
Declaración de variables de matriz
Para usar una matriz en un programa, debe declarar una variable para hacer referencia a la matriz y debe especificar el tipo de matriz a la que la variable puede hacer referencia.
La siguiente es la sintaxis para declarar una variable de matriz.
Sintaxis
var z:Array[String] = new Array[String](3)
or
var z = new Array[String](3)
Aquí, z se declara como una matriz de cadenas que pueden contener hasta tres elementos. Los valores se pueden asignar a elementos individuales u obtener acceso a elementos individuales, se puede hacer usando comandos como los siguientes:
Mando
z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"
Aquí, el último ejemplo muestra que, en general, el índice puede ser cualquier expresión que arroje un número entero. Hay una forma más de definir una matriz:
var z = Array("Zara", "Nuha", "Ayan")
La siguiente imagen representa una matriz myList. Aquí,myList contiene diez valores dobles y los índices van de 0 a 9.
Procesamiento de matrices
Cuando procesamos elementos de matriz, a menudo usamos estructuras de control de bucle porque todos los elementos de una matriz son del mismo tipo y se conoce el tamaño de la matriz.
A continuación se muestra un programa de ejemplo que muestra cómo crear, inicializar y procesar matrices:
Ejemplo
object Demo {
def main(args: Array[String]) {
var myList = Array(1.9, 2.9, 3.4, 3.5)
// Print all the array elements
for ( x <- myList ) {
println( x )
}
// Summing all elements
var total = 0.0;
for ( i <- 0 to (myList.length - 1)) {
total += myList(i);
}
println("Total is " + total);
// Finding the largest element
var max = myList(0);
for ( i <- 1 to (myList.length - 1) ) {
if (myList(i) > max) max = myList(i);
}
println("Max is " + max);
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
Scala no admite directamente varias operaciones de matrices y proporciona varios métodos para procesar matrices en cualquier dimensión. Si desea utilizar los diferentes métodos, es necesario importarArray._ paquete.
Matrices multidimensionales
Hay muchas situaciones en las que necesitaría definir y utilizar matrices multidimensionales (es decir, matrices cuyos elementos son matrices). Por ejemplo, las matrices y tablas son ejemplos de estructuras que se pueden realizar como matrices bidimensionales.
El siguiente es el ejemplo de definición de una matriz bidimensional:
var myMatrix = ofDim[Int](3,3)
Esta es una matriz que tiene tres elementos, cada uno de los cuales es una matriz de números enteros que tiene tres elementos.
Pruebe el siguiente programa de ejemplo para procesar una matriz multidimensional:
Ejemplo
import Array._
object Demo {
def main(args: Array[String]) {
var myMatrix = ofDim[Int](3,3)
// build a matrix
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
myMatrix(i)(j) = j;
}
}
// Print two dimensional array
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
print(" " + myMatrix(i)(j));
}
println();
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
0 1 2
0 1 2
0 1 2
Concatenar matrices
Pruebe el siguiente ejemplo que utiliza el método concat () para concatenar dos matrices. Puede pasar más de una matriz como argumentos al método concat ().
Ejemplo
import Array._
object Demo {
def main(args: Array[String]) {
var myList1 = Array(1.9, 2.9, 3.4, 3.5)
var myList2 = Array(8.9, 7.9, 0.4, 1.5)
var myList3 = concat( myList1, myList2)
// Print all the array elements
for ( x <- myList3 ) {
println( x )
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5
Crear matriz con rango
Uso del método range () para generar una matriz que contiene una secuencia de números enteros crecientes en un rango dado. Puede utilizar el argumento final como paso para crear la secuencia; si no usa el argumento final, se supondrá que el paso es 1.
Tomemos un ejemplo de creación de una matriz de rango (10, 20, 2): Significa crear una matriz con elementos entre 10 y 20 y una diferencia de rango 2. Los elementos de la matriz son 10, 12, 14, 16 y 18 .
Otro ejemplo: rango (10, 20). Aquí no se da la diferencia de rango, por lo que de forma predeterminada se asume 1 elemento. Crea una matriz con los elementos entre 10 y 20 con una diferencia de rango 1. Los elementos de la matriz son 10, 11, 12, 13,… y 19.
El siguiente programa de ejemplo muestra cómo crear una matriz con rangos.
Ejemplo
import Array._
object Demo {
def main(args: Array[String]) {
var myList1 = range(10, 20, 2)
var myList2 = range(10,20)
// Print all the array elements
for ( x <- myList1 ) {
print( " " + x )
}
println()
for ( x <- myList2 ) {
print( " " + x )
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
10 12 14 16 18
10 11 12 13 14 15 16 17 18 19
Métodos de matriz Scala
A continuación se muestran los métodos importantes que puede utilizar mientras juega con array. Como se muestra arriba, tendría que importarArray._paquete antes de utilizar cualquiera de los métodos mencionados. Para obtener una lista completa de los métodos disponibles, consulte la documentación oficial de Scala.
No Señor | Métodos con descripción |
---|---|
1 | def apply( x: T, xs: T* ): Array[T] Crea una matriz de objetos T, donde T puede ser Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean. |
2 | def concat[T]( xss: Array[T]* ): Array[T] Concatena todas las matrices en una única matriz. |
3 | def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit Copie una matriz a otra. Equivalente a System.arraycopy de Java (src, srcPos, dest, destPos, length). |
4 | def empty[T]: Array[T] Devuelve una matriz de longitud 0 |
5 | def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T] Devuelve una matriz que contiene aplicaciones repetidas de una función a un valor inicial. |
6 | def fill[T]( n: Int )(elem: => T): Array[T] Devuelve una matriz que contiene los resultados de algunos cálculos de elementos varias veces. |
7 | def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]] Devuelve una matriz bidimensional que contiene los resultados de algunos cálculos de elementos varias veces. |
8 | def iterate[T]( start: T, len: Int)( f: (T) => T ): Array[T] Devuelve una matriz que contiene aplicaciones repetidas de una función a un valor inicial. |
9 | def ofDim[T]( n1: Int ): Array[T] Crea una matriz con las dimensiones dadas. |
10 | def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] Crea una matriz bidimensional |
11 | def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] Crea una matriz tridimensional |
12 | def range( start: Int, end: Int, step: Int ): Array[Int] Devuelve una matriz que contiene valores igualmente espaciados en algún intervalo de enteros. |
13 | def range( start: Int, end: Int ): Array[Int] Devuelve una matriz que contiene una secuencia de números enteros crecientes en un rango. |
14 | def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] Devuelve una matriz que contiene valores de una función determinada en un rango de valores enteros a partir de 0. |
15 | def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] Devuelve una matriz bidimensional que contiene valores de una función determinada en rangos de valores enteros a partir de 0. |
Scala tiene un amplio conjunto de bibliotecas de colecciones. Las colecciones son contenedores de cosas. Esos contenedores pueden ser conjuntos lineales de elementos secuenciados como Lista, Tupla, Opción, Mapa, etc. Las colecciones pueden tener un número arbitrario de elementos o estar delimitadas a cero o un elemento (por ejemplo, Opción).
Las colecciones pueden ser strict o lazy. Las colecciones diferidas tienen elementos que pueden no consumir memoria hasta que se accede a ellos, comoRanges. Además, las colecciones pueden sermutable (el contenido de la referencia puede cambiar) o immutable(la cosa a la que se refiere una referencia nunca se cambia). Tenga en cuenta que las colecciones inmutables pueden contener elementos mutables.
Para algunos problemas, las colecciones mutables funcionan mejor, y para otros, las colecciones inmutables funcionan mejor. En caso de duda, es mejor comenzar con una colección inmutable y cambiarla más tarde si necesita otras.
Este capítulo arroja luz sobre los tipos de colección más utilizados y las operaciones más utilizadas sobre esas colecciones.
No Señor | Colecciones con descripción |
---|---|
1 | Scala Lists La Lista de Scala [T] es una lista enlazada de tipo T. |
2 | Scala Sets Un conjunto es una colección de elementos diferentes del mismo tipo por pares. |
3 | Scala Maps Un mapa es una colección de pares clave / valor. Cualquier valor se puede recuperar según su clave. |
4 | Scala Tuples A diferencia de una matriz o lista, una tupla puede contener objetos con diferentes tipos. |
5 | Scala Options La opción [T] proporciona un contenedor para cero o un elemento de un tipo determinado. |
6 | Scala Iterators Un iterador no es una colección, sino una forma de acceder a los elementos de una colección uno por uno. |
Un rasgo encapsula las definiciones de métodos y campos, que luego se pueden reutilizar mezclándolos en clases. A diferencia de la herencia de clases, en la que cada clase debe heredar de una sola superclase, una clase puede mezclar cualquier número de rasgos.
Los rasgos se utilizan para definir tipos de objetos especificando la firma de los métodos admitidos. Scala también permite que los rasgos se implementen parcialmente, pero es posible que los rasgos no tengan parámetros de constructor.
Una definición de rasgo se parece a una definición de clase, excepto que usa la palabra clave trait. El siguiente es el ejemplo básico de sintaxis de rasgo.
Sintaxis
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
Este rasgo consta de dos métodos isEqual y isNotEqual. Aquí, no hemos proporcionado ninguna implementación para isEqual donde otro método tiene su implementación. Las clases secundarias que extienden un rasgo pueden dar implementación a los métodos no implementados. Entonces, un rasgo es muy similar a lo que tenemosabstract classes en Java.
Asumamos un ejemplo de rasgo Equal contener dos métodos isEqual() y isNotEqual(). El rasgoEqual contienen un método implementado que es isEqual() así que cuando la clase definida por el usuario Point extiende el rasgo Equal, implementación a isEqual() método en Point debe proporcionarse la clase.
Aquí se requiere conocer dos métodos importantes de Scala, que se utilizan en el siguiente ejemplo.
obj.isInstanceOf [Point] Para comprobar el tipo de obj y el punto son iguales, no lo son.
obj.asInstanceOf [Point] significa conversión exacta tomando el tipo de objeto obj y devuelve el mismo obj que el tipo de punto.
Pruebe el siguiente programa de ejemplo para implementar rasgos.
Ejemplo
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
class Point(xc: Int, yc: Int) extends Equal {
var x: Int = xc
var y: Int = yc
def isEqual(obj: Any) = obj.isInstanceOf[Point] && obj.asInstanceOf[Point].x == y
}
object Demo {
def main(args: Array[String]) {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotEqual(p2))
println(p1.isNotEqual(p3))
println(p1.isNotEqual(2))
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
true
false
true
Clases de valor y rasgos universales
Las clases de valor son un nuevo mecanismo en Scala para evitar la asignación de objetos en tiempo de ejecución. Contiene un constructor principal con exactamente unovalparámetro. Contiene solo métodos (def) no permitidos var, val, clases anidadas, rasgos u objetos. La clase de valor no se puede ampliar con otra clase. Esto puede ser posible ampliando su clase de valor con AnyVal. La seguridad de tipos de tipos de datos personalizados sin la sobrecarga del tiempo de ejecución.
Tomemos ejemplos de clases de valor Peso, Altura, Correo electrónico, Edad, etc. Para todos estos ejemplos no es necesario asignar memoria en la aplicación.
Una clase de valor que no puede extender rasgos. Para permitir que las clases de valor amplíen los rasgos,universal traits se introducen que se extiende por Any.
Ejemplo
trait Printable extends Any {
def print(): Unit = println(this)
}
class Wrapper(val underlying: Int) extends AnyVal with Printable
object Demo {
def main(args: Array[String]) {
val w = new Wrapper(3)
w.print() // actually requires instantiating a Wrapper instance
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Te dará el código hash de la clase Wrapper.
Wrapper@13
¿Cuándo usar rasgos?
No existe una regla firme, pero aquí hay algunas pautas a considerar:
Si el comportamiento no se reutilizará, conviértalo en una clase concreta. Después de todo, no es un comportamiento reutilizable.
Si puede reutilizarse en varias clases no relacionadas, conviértalo en un rasgo. Solo los rasgos se pueden mezclar en diferentes partes de la jerarquía de clases.
Si quieres inherit a partir de él en código Java, use una clase abstracta.
Si planea distribuirlo en forma compilada y espera que grupos externos escriban clases heredadas de él, puede inclinarse por usar una clase abstracta.
Si la eficiencia es muy importante, apóyate en usar una clase.
La coincidencia de patrones es la segunda característica más utilizada de Scala, después de los valores y cierres de funciones. Scala proporciona un gran soporte para la coincidencia de patrones en el procesamiento de mensajes.
Una coincidencia de patrón incluye una secuencia de alternativas, cada una de las cuales comienza con la palabra clave case. Cada alternativa incluye unpattern y uno o mas expressions, que se evaluará si el patrón coincide. Un símbolo de flecha => separa el patrón de las expresiones.
Pruebe el siguiente programa de ejemplo, que muestra cómo hacer coincidir con un valor entero.
Ejemplo
object Demo {
def main(args: Array[String]) {
println(matchTest(3))
}
def matchTest(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
many
El bloque con las sentencias case define una función, que asigna números enteros a cadenas. La palabra clave de coincidencia proporciona una forma conveniente de aplicar una función (como la función de coincidencia de patrones anterior) a un objeto.
Pruebe el siguiente programa de ejemplo, que compara un valor con patrones de diferentes tipos.
Ejemplo
object Demo {
def main(args: Array[String]) {
println(matchTest("two"))
println(matchTest("test"))
println(matchTest(1))
}
def matchTest(x: Any): Any = x match {
case 1 => "one"
case "two" => 2
case y: Int => "scala.Int"
case _ => "many"
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
2
many
one
Coincidencia mediante clases de casos
los case classesson clases especiales que se utilizan en la coincidencia de patrones con expresiones de casos. Sintácticamente, estas son clases estándar con un modificador especial:case.
Intente lo siguiente, es un ejemplo de coincidencia de patrones simple usando la clase de caso.
Ejemplo
object Demo {
def main(args: Array[String]) {
val alice = new Person("Alice", 25)
val bob = new Person("Bob", 32)
val charlie = new Person("Charlie", 32)
for (person <- List(alice, bob, charlie)) {
person match {
case Person("Alice", 25) => println("Hi Alice!")
case Person("Bob", 32) => println("Hi Bob!")
case Person(name, age) => println(
"Age: " + age + " year, name: " + name + "?")
}
}
}
case class Person(name: String, age: Int)
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Hi Alice!
Hi Bob!
Age: 32 year, name: Charlie?
Agregar la palabra clave case hace que el compilador agregue automáticamente una serie de funciones útiles. La palabra clave sugiere una asociación con expresiones de casos en la coincidencia de patrones.
Primero, el compilador convierte automáticamente los argumentos del constructor en campos inmutables (vals). La palabra clave val es opcional. Si desea campos mutables, use la palabra clave var. Entonces, nuestras listas de argumentos de constructor ahora son más cortas.
En segundo lugar, el compilador implementa automáticamente equals, hashCode, y toStringmétodos a la clase, que utilizan los campos especificados como argumentos del constructor. Entonces, ya no necesitamos nuestros propios métodos toString ().
Finalmente, también, el cuerpo de Person la clase se vuelve vacía porque no hay métodos que debamos definir.
Este capítulo explica cómo Scala admite expresiones regulares a través de Regex class disponible en el paquete scala.util.matching.
Pruebe el siguiente programa de ejemplo donde intentaremos encontrar la palabra Scala de una declaración.
Ejemplo
import scala.util.matching.Regex
object Demo {
def main(args: Array[String]) {
val pattern = "Scala".r
val str = "Scala is Scalable and cool"
println(pattern findFirstIn str)
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Some(Scala)
Creamos un String y llamamos al r( )método en él. Scala convierte implícitamente el String en un RichString e invoca ese método para obtener una instancia de Regex. Para encontrar una primera coincidencia de la expresión regular, simplemente llame alfindFirstIn()método. Si en lugar de encontrar solo la primera aparición nos gustaría encontrar todas las apariciones de la palabra coincidente, podemos usar lafindAllIn( ) y en caso de que haya varias palabras Scala disponibles en la cadena de destino, esto devolverá una colección de todas las palabras coincidentes.
Puede hacer uso del método mkString () para concatenar la lista resultante y puede usar una tubería (|) para buscar mayúsculas y minúsculas de Scala y puede usar Regex constructor en su lugar o r() método para crear un patrón.
Pruebe el siguiente programa de ejemplo.
Ejemplo
import scala.util.matching.Regex
object Demo {
def main(args: Array[String]) {
val pattern = new Regex("(S|s)cala")
val str = "Scala is scalable and cool"
println((pattern findAllIn str).mkString(","))
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Scala,scala
Si desea reemplazar el texto coincidente, podemos usar replaceFirstIn( ) para reemplazar el primer partido o replaceAllIn( ) para reemplazar todas las ocurrencias.
Ejemplo
object Demo {
def main(args: Array[String]) {
val pattern = "(S|s)cala".r
val str = "Scala is scalable and cool"
println(pattern replaceFirstIn(str, "Java"))
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Java is scalable and cool
Formando expresiones regulares
Scala hereda su sintaxis de expresión regular de Java, que a su vez hereda la mayoría de las características de Perl. Estos son solo algunos ejemplos que deberían ser suficientes como recordatorios:
A continuación se muestra la tabla que enumera toda la sintaxis de caracteres meta de expresión regular disponible en Java.
Subexpresión | Partidos |
---|---|
^ | Coincide con el comienzo de la línea. |
PS | Coincide con el final de la línea. |
. | Coincide con cualquier carácter, excepto la nueva línea. El uso de la opción m también le permite hacer coincidir la nueva línea. |
[...] | Coincide con cualquier carácter individual entre paréntesis. |
[^ ...] | Coincide con cualquier carácter individual que no esté entre corchetes |
\\UN | Comienzo de toda la cadena |
\\ z | Fin de toda la cadena |
\\ Z | Fin de toda la cadena excepto el terminador de línea final permitido. |
re* | Coincide con 0 o más apariciones de la expresión anterior. |
re + | Coincide con 1 o más de lo anterior |
¿re? | Coincide con 0 o 1 aparición de la expresión anterior. |
re {n} | Coincide exactamente con n número de apariciones de la expresión anterior. |
re {n,} | Coincide con no más apariciones de la expresión anterior. |
re {n, m} | Coincide con al menos n y como máximo m apariciones de la expresión anterior. |
a | b | Coincide con a o b. |
(re) | Agrupa expresiones regulares y recuerda texto coincidente. |
(?: re) | Agrupa expresiones regulares sin recordar el texto coincidente. |
(?> re) | Coincide con el patrón independiente sin retroceso. |
\\ w | Coincide con caracteres de palabra. |
\\ W | Coincide con caracteres que no son palabras. |
\\ s | Coincide con los espacios en blanco. Equivalente a [\ t \ n \ r \ f]. |
\\ S | Coincide con espacios que no son en blanco. |
\\re | Coincide con dígitos. Equivalente a [0-9]. |
\\RE | Coincide con no dígitos. |
\\UN | Coincide con el comienzo de la cadena. |
\\ Z | Coincide con el final de la cuerda. Si existe una nueva línea, coincide justo antes de la nueva línea. |
\\ z | Coincide con el final de la cuerda. |
\\GRAMO | Los partidos apuntan donde terminó el último partido. |
\\norte | Referencia inversa para capturar el número de grupo "n" |
\\segundo | Coincide con los límites de las palabras cuando están fuera de los corchetes. Coincide con el retroceso (0x08) cuando está dentro de los corchetes. |
\\SEGUNDO | Coincide con los límites que no son palabras. |
\\ n, \\ t, etc. | Coincide con nuevas líneas, retornos de carro, pestañas, etc. |
\\ Q | Escape (comillas) todos los caracteres hasta \\ E |
\\MI | Termina la cotización que comenzó con \\ Q |
Ejemplos de expresiones regulares
Ejemplo | Descripción |
---|---|
. | Coincidir con cualquier carácter excepto nueva línea |
[Rr] uby | Coincidir con "Ruby" o "ruby" |
frotar [ye] | Coincidir con "ruby" o "rube" |
[aeiou] | Coincidir con cualquier vocal minúscula |
[0-9] | Coincidir con cualquier dígito; igual que [0123456789] |
[Arizona] | Coincidir con cualquier letra ASCII minúscula |
[ARIZONA] | Coincide con cualquier letra ASCII mayúscula |
[a-zA-Z0-9] | Coincide con cualquiera de los anteriores |
[^ aeiou] | Coincidir con cualquier cosa que no sea una vocal minúscula |
[^ 0-9] | Coincide con cualquier cosa que no sea un dígito |
\\re | Coincide con un dígito: [0-9] |
\\RE | Coincidir con un no dígito: [^ 0-9] |
\\ s | Coincide con un carácter de espacio en blanco: [\ t \ r \ n \ f] |
\\ S | Coincidir con espacios que no son en blanco: [^ \ t \ r \ n \ f] |
\\ w | Coincide con un carácter de una sola palabra: [A-Za-z0-9_] |
\\ W | Coincide con un carácter que no es una palabra: [^ A-Za-z0-9_] |
¿rubí? | Coincidir con "rub" o "ruby": la y es opcional |
rubí* | Coincide con "frotar" más 0 o más ys |
rubí + | Coincide con "frotar" más 1 o más ys |
\\ d {3} | Coincidir exactamente con 3 dígitos |
\\ d {3,} | Coincide con 3 o más dígitos |
\\ d {3,5} | Coincide con 3, 4 o 5 dígitos |
\\ D \\ d + | Ningún grupo: + repite \\ d |
(\\ D \\ d) + / | Agrupados: + repeticiones \\ D \ d par |
([Rr] uby (,)?) + | Coincide con "Ruby", "Ruby, ruby, ruby", etc. |
Note- que cada barra invertida aparece dos veces en la cadena de arriba. Esto se debe a que en Java y Scala una sola barra invertida es un carácter de escape en una cadena literal, no un carácter regular que aparece en la cadena. Entonces, en lugar de '\', debe escribir '\\' para obtener una sola barra invertida en la cadena.
Pruebe el siguiente programa de ejemplo.
Ejemplo
import scala.util.matching.Regex
object Demo {
def main(args: Array[String]) {
val pattern = new Regex("abl[ae]\\d+")
val str = "ablaw is able1 and cool"
println((pattern findAllIn str).mkString(","))
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
able1
Las excepciones de Scala funcionan como excepciones en muchos otros lenguajes como Java. En lugar de devolver un valor de la forma normal, un método puede terminar lanzando una excepción. Sin embargo, Scala en realidad no tiene excepciones comprobadas.
Cuando desee manejar excepciones, use un bloque try {...} catch {...} como lo haría en Java, excepto que el bloque catch usa la coincidencia para identificar y manejar las excepciones.
Lanzar excepciones
Lanzar una excepción tiene el mismo aspecto que en Java. Creas un objeto de excepción y luego lo lanzas con elthrow palabra clave de la siguiente manera.
throw new IllegalArgumentException
Captura de excepciones
Scala te permite try/catch cualquier excepción en un solo bloque y luego realice la comparación de patrones con él usando casebloques. Pruebe el siguiente programa de ejemplo para manejar la excepción.
Ejemplo
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
object Demo {
def main(args: Array[String]) {
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException =>{
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Missing file exception
El comportamiento de este try-catchLa expresión es la misma que en otros idiomas con excepciones. El cuerpo se ejecuta, y si arroja una excepción, cadacatch la cláusula se prueba a su vez.
La cláusula finalmente
Puede envolver una expresión con un finallycláusula si desea que se ejecute algún código sin importar cómo termine la expresión. Prueba el siguiente programa.
Ejemplo
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
object Demo {
def main(args: Array[String]) {
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException => {
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
} finally {
println("Exiting finally...")
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Missing file exception
Exiting finally...
Un extractor en Scala es un objeto que tiene un método llamado unapplycomo uno de sus miembros. El propósito de ese método de no aplicar es hacer coincidir un valor y desarmarlo. A menudo, el objeto extractor también define un método dualapply para construir valores, pero esto no es obligatorio.
Ejemplo
Tomemos un ejemplo de objeto define tanto apply y unapplymétodos. El método de aplicación tiene el mismo significado que siempre: convierte a Test en un objeto que se puede aplicar a los argumentos entre paréntesis de la misma manera que se aplica un método. Entonces puede escribir Test ("Zara", "gmail.com") para construir la cadena "[email protected]".
los unapply El método es lo que convierte la clase Test en un extractor e invierte el proceso de construcción de apply. Donde aplicar toma dos cadenas y forma una cadena de dirección de correo electrónico a partir de ellas, una aplicación toma una dirección de correo electrónico y devuelve potencialmente dos cadenas:user y el domain de la dirección.
los unapplytambién debe manejar el caso donde la cadena dada no es una dirección de correo electrónico. Es por eso que unapply devuelve un tipo Option sobre pares de cadenas. Su resultado esSome (user, domain)si la cadena str es una dirección de correo electrónico con el usuario y las partes del dominio dadas, o Ninguno, si str no es una dirección de correo electrónico. A continuación se muestran algunos ejemplos.
Sintaxis
unapply("[email protected]") equals Some("Zara", "gmail.com")
unapply("Zara Ali") equals None
El siguiente programa de ejemplo muestra un objeto extractor para direcciones de correo electrónico.
Ejemplo
object Demo {
def main(args: Array[String]) {
println ("Apply method : " + apply("Zara", "gmail.com"));
println ("Unapply method : " + unapply("[email protected]"));
println ("Unapply method : " + unapply("Zara Ali"));
}
// The injection method (optional)
def apply(user: String, domain: String) = {
user +"@"+ domain
}
// The extraction method (mandatory)
def unapply(str: String): Option[(String, String)] = {
val parts = str split "@"
if (parts.length == 2){
Some(parts(0), parts(1))
} else {
None
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Apply method : [email protected]
Unapply method : Some((Zara,gmail.com))
Unapply method : None
Coincidencia de patrones con extractores
Cuando una instancia de una clase va seguida de paréntesis con una lista de cero o más parámetros, el compilador invoca el applymétodo en esa instancia. Podemos definir aplicar tanto en objetos como en clases.
Como se mencionó anteriormente, el propósito de la unapplyEl método consiste en extraer un valor específico que estamos buscando. Hace la operación contrariaapplyhace. Al comparar un objeto extractor utilizando elmatch declaración el unapply El método se ejecutará automáticamente.
Pruebe el siguiente programa de ejemplo.
Ejemplo
object Demo {
def main(args: Array[String]) {
val x = Demo(5)
println(x)
x match {
case Demo(num) => println(x+" is bigger two times than "+num)
//unapply is invoked
case _ => println("i cannot calculate")
}
}
def apply(x: Int) = x*2
def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2) else None
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
10
10 is bigger two times than 5
Scala está abierto para hacer uso de cualquier objeto Java y java.io.File es uno de los objetos que se pueden utilizar en la programación de Scala para leer y escribir archivos.
El siguiente es un programa de ejemplo para escribir en un archivo.
Ejemplo
import java.io._
object Demo {
def main(args: Array[String]) {
val writer = new PrintWriter(new File("test.txt" ))
writer.write("Hello Scala")
writer.close()
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Creará un archivo llamado Demo.txten el directorio actual, donde se coloca el programa. El siguiente es el contenido de ese archivo.
Salida
Hello Scala
Leer una línea desde la línea de comandos
En algún momento, debe leer la entrada del usuario en la pantalla y luego continuar con el procesamiento adicional. El siguiente programa de ejemplo le muestra cómo leer la entrada desde la línea de comando.
Ejemplo
object Demo {
def main(args: Array[String]) {
print("Please enter your input : " )
val line = Console.readLine
println("Thanks, you just typed: " + line)
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Please enter your input : Scala is great
Thanks, you just typed: Scala is great
Leer el contenido del archivo
Leer archivos es realmente sencillo. Puedes usar Scala'sSourceclass y su objeto complementario para leer archivos. A continuación se muestra el ejemplo que le muestra cómo leer de"Demo.txt" archivo que creamos anteriormente.
Ejemplo
import scala.io.Source
object Demo {
def main(args: Array[String]) {
println("Following is the content read:" )
Source.fromFile("Demo.txt" ).foreach {
print
}
}
}
Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.
Mando
\>scalac Demo.scala
\>scala Demo
Salida
Following is the content read:
Hello Scala