En Scala, declarar variables es un proceso que se realiza con palabras clave específicas que nos indican cómo queremos que se comporte esa variable. La palabra clave principal para definir una variable es val. Cuando usamos val, estamos creando un valor inmutable, es decir, una variable cuyo contenido no podrá cambiar una vez asignado. Por ejemplo, si declaramos val a = 5, estamos diciendo que a es una variable que vale 5 y que ese valor permanecerá constante durante todo el ciclo de vida de a.
Una característica muy interesante de Scala es su sistema de inferencia de tipos. Esto significa que no es necesario especificar explícitamente el tipo de la variable, ya que el compilador lo deduce automáticamente a partir del valor que le asignamos. Por ejemplo, al escribir val a = 5, Scala entiende que a es un entero. Sin embargo, si queremos, podemos indicar el tipo de forma explícita, como en val b: Double = 5.0, donde le decimos que b es un número de punto flotante doble precisión. Esta inferencia de tipos no solo hace que el código sea más limpio, sino que también aporta seguridad, ya que el compilador nos avisará si intentamos asignar un valor incompatible con el tipo esperado.
Un aspecto fundamental en Scala es la distinción entre variables mutables e inmutables. Las variables declaradas con val son inmutables, lo que significa que no podemos cambiar su valor una vez asignado. Si intentamos reasignar un valor a un val, el compilador nos mostrará un error. Esto puede parecer extraño al principio, especialmente si venimos de lenguajes donde las variables cambian de valor libremente, pero tiene una razón de ser muy importante: la inmutabilidad ayuda a evitar problemas en entornos concurrentes y hace que el código sea más predecible y seguro. Al no poder cambiar el valor de una variable, podemos estar seguros de que ninguna función o hilo externo modificará ese valor sin nuestro consentimiento explícito.
Por otro lado, si necesitamos variables que puedan cambiar de valor, Scala nos ofrece la palabra clave var. Al declarar una variable con var, como en var b = 10, podemos reasignar valores a esa variable tantas veces como queramos, por ejemplo, b = 5 o b = 20. Sin embargo, es recomendable usar var con precaución y preferir siempre val cuando sea posible, ya que la inmutabilidad aporta ventajas en la claridad y seguridad del código.
Un detalle a tener en cuenta es que, en el intérprete de Scala, puede parecer que es posible cambiar el valor de un val, pero esto es una peculiaridad del entorno interactivo. En código real, fuera del intérprete, el compilador no permitirá esa reasignación.
En resumen, en Scala tenemos dos formas de declarar variables: val para valores inmutables y var para variables mutables. La recomendación general es usar val siempre que sea posible para aprovechar las ventajas de la inmutabilidad, y recurrir a var solo cuando sea estrictamente necesario. Esta filosofía ayuda a escribir código más seguro, especialmente en programas que manejan concurrencia o que requieren un comportamiento predecible.
Para ilustrar lo que hemos comentado, aquí un ejemplo sencillo:
val a = 5 // a es un valor inmutable de tipo Int
var b: Double = 10 // b es una variable mutable de tipo Double
println(a) // Imprime 5
println(b) // Imprime 10.0
// b puede cambiar de valor
b = 20.5
println(b) // Imprime 20.5
// a = 10 // Esto daría error: no se puede reasignar un val
Así, al trabajar con val y var, podemos controlar mejor el comportamiento de nuestras variables y escribir código más robusto y fácil de mantener.