Variables en Scala

Una variable es un marcador de posición conveniente que se utiliza para hacer referencia a direcciones de memoria de la computadora. Después de crear una variable, esta ocupa cierta cantidad de espacio de memoria.

Según el tipo de datos de la variable, el sistema operativo realiza la asignación de memoria y determina qué se almacenará en la memoria reservada. Por lo tanto, al asignar diferentes tipos de datos a las variables, puedes almacenar enteros, decimales o letras en estas variables.

Declaración de variables

Antes de aprender a declarar variables y constantes, primero comprendamos qué son las variables y las constantes.

Variable:Una cantidad cuyo valor puede cambiar durante la ejecución del programa se llama variable. Por ejemplo: el tiempo, la edad.
Constante:Una cantidad cuyo valor no cambia durante la ejecución del programa se llama constante. Por ejemplo: el número 3, el carácter 'A'.

En Scala, se usa la palabra clave"var"para declarar variables, y la palabra clave"val"para declarar constantes.

Variable inmutable (val):

Usandovallas variables declaradas con la palabra clave son inmutables, es decir, una vez que se les asigna un valor, este no puede modificarse.
Similar a lafinalvariable en Java.

Variable mutable (var):

Usandovarlas variables declaradas con la palabra clave son mutables y su valor puede modificarse varias veces durante el ciclo de vida del programa.
Similar a las variables normales en Java.

Un ejemplo de declaración de variables es el siguiente:

var myVar : String = "Foo"
var myVar : String = "Too"

Lo anterior define la variable myVar, que podemos modificar.

Un ejemplo de declaración de una constante es el siguiente:

val myVal : String = "Foo"

Lo anterior define la constante myVal, que no se puede modificar. Si el programa intenta modificar el valor de la constante myVal, se producirá un error en tiempo de compilación.

Declaración de tipos de variables

El tipo de la variable se declara después del nombre de la variable y antes del signo igual. El formato de sintaxis para definir el tipo de una variable es el siguiente:

var VariableName : DataType [=  Initial Value]

o 

val VariableName : DataType [=  Initial Value]

Ejemplo

object VariableExample {
def main(args: Array[String]): Unit = {
// Declarar una variable inmutable
val immutableVariable: Int = 10
println(s"Immutable Variable: $immutableVariable")

// Declarar una variable mutable
var mutableVariable: Int = 20
println(s"Mutable Variable: $mutableVariable")

// Modificar el valor de la variable mutable
mutableVariable = 30
println(s"Updated Mutable Variable: $mutableVariable")

// Las variables inmutables no pueden ser reasignadas, esto causará un error de compilación
// immutableVariable = 15 // Uncommenting this line will cause a compilation error
}
}

La salida de la ejecución del código anterior es:

Immutable Variable: 10
Mutable Variable: 20
Updated Mutable Variable: 30

Reglas de nomenclatura de variables

Caracteres válidos：

El nombre de la variable debe comenzar con una letra (A-Z o a-z) o con un guion bajo (_).
Los caracteres siguientes pueden ser letras, dígitos (0-9) o guiones bajos.
El nombre de la variable no puede ser una palabra clave de Scala.

Notación camelCase：

Los nombres de variables suelen usar la notación camelCase, es decir, la primera palabra comienza con una letra minúscula y la primera letra de las palabras siguientes va en mayúscula.
Por ejemplo:myVariableName, userAge, accountBalance。

Evitar nombres de variables de un solo carácter：

Excepto las variables de contador comunes (comoi, j, k), se debe evitar en lo posible usar nombres de variables de un solo carácter para mejorar la legibilidad del código.

Nombres de variables significativos：

El nombre de la variable debe expresar claramente su propósito o significado, evitando nombres ambiguos o sin sentido.
Por ejemplo:val age: Int = 25es mejor queval a: Int = 25。

Reglas de nomenclatura específicas de Scala：

Evita usar nombres de variables que comiencen con guion bajo; esto suele usarse para identificar variables internas o privadas.
Se pueden usar combinaciones de letras y símbolos para nombrar funciones y métodos, pero esto es poco común en la nomenclatura de variables.
Evita usar combinaciones de símbolos similares a operadores (como++，--) como nombres de variables, ya que esto dificulta la lectura y comprensión del código.

Referencia de tipos de variables

En Scala, declarar variables y constantes no requiere especificar necesariamente el tipo de datos. Cuando no se especifica el tipo de datos, este se infiere a partir del valor inicial de la variable o constante.

Por lo tanto, si se declara una variable o constante sin especificar el tipo de datos, se debe proporcionar su valor inicial; de lo contrario, se producirá un error.

Declaración explícita de tipos: especifica claramente el tipo de la variable.
Inferencia de tipos: omite la declaración de tipo y el compilador infiere el tipo.

El mecanismo de inferencia de tipos de Scala puede determinar automáticamente el tipo de una variable, por lo que podemos omitir la declaración de tipo:

val inferredInt = 42  // 编译器推断为 Int
val inferredDouble = 3.14  // 编译器推断为 Double
val inferredString = "Hello, Scala!"  // 编译器推断为 String
val inferredBoolean = true  // 编译器推断为 Boolean

La inferencia de tipos hace que el código sea más conciso, pero en escenarios complejos, declarar explícitamente el tipo puede evitar confusiones.

Al declarar explícitamente el tipo, se colocan dos puntos y el tipo de datos después del nombre de la variable:

val explicitInt: Int = 42
val explicitDouble: Double = 3.14
val explicitString: String = "Hello, Scala!"
val explicitBoolean: Boolean = true

La declaración explícita ayuda a mejorar la legibilidad y el mantenimiento del código, especialmente cuando el tipo no es fácil de inferir o puede causar confusión.

Ejemplo

object VariableTypesExample {
def main(args: Array[String]): Unit = {
// Declaración explícita de tipo
val explicitInt: Int = 42
val explicitDouble: Double = 3.14
val explicitString: String = "Hello, Scala!"
val explicitBoolean: Boolean = true

// Inferencia de tipos
val inferredInt = 42 // El compilador infiere Int
val inferredDouble = 3.14 // El compilador infiere Double
val inferredString = "Hello, Scala!" // El compilador infiere String
val inferredBoolean = true // El compilador infiere Boolean

// Variable mutable
var mutableInt: Int = 10
println(s"Initial mutableInt: $mutableInt")
mutableInt = 20 // Modificar el valor de la variable
println(s"Updated mutableInt: $mutableInt")

// Imprimir todas las variables
println(s"Explicit Int: $explicitInt")
println(s"Explicit Double: $explicitDouble")
println(s"Explicit String: $explicitString")
println(s"Explicit Boolean: $explicitBoolean")

println(s"Inferred Int: $inferredInt")
println(s"Inferred Double: $inferredDouble")
println(s"Inferred String: $inferredString")
println(s"Inferred Boolean: $inferredBoolean")
}
}

La salida de la ejecución del código anterior es:

Initial mutableInt: 10
Updated mutableInt: 20
Explicit Int: 42
Explicit Double: 3.14
Explicit String: Hello, Scala!
Explicit Boolean: true
Inferred Int: 42
Inferred Double: 3.14
Inferred String: Hello, Scala!
Inferred Boolean: true

Declaración de múltiples variables en Scala

En Scala, se pueden declarar múltiples variables al mismo tiempo. Esto no solo hace que el código sea más conciso, sino que también garantiza la relación entre múltiples variables cuando se declaran en la misma línea.

En Scala, se pueden declarar múltiples variables a la vez usando métodos como la separación por comas, la desestructuración de tuplas y las for comprehensions.

Se pueden declarar múltiples variables en una sola línea usando comas:

val xmax, ymax = 100  // xmax, ymax都声明为100

Ejemplo

object MultipleVariables {
def main(args: Array[String]): Unit = {
// Declarar múltiples variables inmutables a la vez
val a, b, c: Int = 5
println(s"a: $a, b: $b, c: $c")

// Declarar múltiples variables mutables a la vez
var x, y, z: Int = 10
println(s"x: $x, y: $y, z: $z")

// Modificar el valor de las variables mutables
x = 20
y = 30
z = 40
println(s"Updated x: $x, y: $y, z: $z")
}
}

Si el valor de retorno de un método es una tupla, podemos usar val para declarar una tupla:

scala> val pa = (40,"Foo")
pa: (Int, String) = (40,Foo)

Ejemplo

object TupleDestructuring {
def main(args: Array[String]): Unit = {
// Usar la desestructuración de tuplas para declarar múltiples variables a la vez
val (a, b, c) = (1, 2, "hello")
println(s"a: $a, b: $b, c: $c")

// Usar la desestructuración de tuplas para declarar múltiples variables mutables a la vez
var (x, y, z) = (10, 20, "world")
println(s"x: $x, y: $y, z: $z")

// Modificar el valor de las variables mutables
x = 30
y = 40
z = "Scala"
println(s"Updated x: $x, y: $y, z: $z")
}
}

Declarar múltiples variables usando for comprehensions

En una for comprehension, se pueden declarar múltiples variables a la vez para iterar y generar nuevas colecciones.

Ejemplo

object ForComprehension {
def main(args: Array[String]): Unit = {
// Declarar múltiples variables a la vez para iterar
val numbers = List((1, "one"), (2, "two"), (3, "three"))
for ((number, word) <- numbers) {
println(s"Number: $number, Word: $word")
}

// Usar una for comprehension para generar una nueva colección
val newNumbers = for {
(number, word) <- numbers
} yield (number * 2, word.toUpperCase)

println(s"New Numbers: $newNumbers")
}
}

Otras extensiones