Variables en Scala

Echa un vistazo al curso de Scala recién lanzado en DataCamp: Introduction to Scala.

Scala es muy utilizado por los científicos de datos para trabajar con grandes volúmenes de datos junto con Apache Spark en el ámbito del Big Data. Es un lenguaje de programación orientado a objetos y funcional a la vez, con muchas características clave como las siguientes:

1. Scala es un lenguaje de tipado estático: el tipo de dato de la variable se define antes de usarla. La comprobación de tipos se realiza en tiempo de compilación, no en tiempo de ejecución.
2. También es un lenguaje de «tipado fuerte», donde las variables se validan antes de operar con ellas.
3. Soporta inferencia de tipos: el compilador deduce el tipo a partir de la expresión o de los literales, por lo que declarar el tipo de la variable es opcional.

En este tutorial, vas a cubrir los siguientes temas:

• Variables
• Reglas para definir variables en Scala
• Variables mutables
• Variables inmutables
• Declaraciones y asignaciones múltiples
• Ámbito de las variables en Scala

Variables

Las variables son espacios con nombre en memoria; el compilador reserva una ubicación según el tipo de dato de la variable correspondiente. En Scala, una variable se declara con la siguiente sintaxis:

val or val variable_name: variable_datatype = value;

En la sintaxis anterior, la variable puede definirse de dos formas, usando las palabras clave "var" o "val". Incluye el 'variable_name' como el nombre de tu nueva variable, seguido de dos puntos. El tipo de dato de la variable es 'variable_datatype', que puede ser cualquier tipo válido. A continuación, 'value' se asigna a 'variable_name'.

Por ejemplo:

val varValue: Byte = 8;

'val' es la palabra clave para definir la variable, y 'varValue' es el nombre de la variable. Es de tipo 'Byte' y contiene el valor 8. 'Byte' es un entero con signo de 8 bits, cuyo rango va de 2⁻⁷ a 2⁷−1.

El 'variable_datatype' anterior puede ser cualquiera de los tipos de datos que existen en Scala, por ejemplo:

1. Int: entero con signo de 32 bits (positivo o negativo), con un rango de 2⁻³¹ a 2³¹−1.
2. Byte: entero con signo de 8 bits, con un rango de 2⁻⁷ a 2⁷−1.
3. Short: entero con signo de 16 bits, con un rango de 2⁻¹⁵ a 2¹⁵−1.
4. Float: puede ser de 32 o 64 bits.

De forma similar, otros tipos como Long, Char, Boolean, Char, String, Boolean, Null tienen su propio rango. Tienes una explicación detallada en el tutorial Beginner’s Guide to Scala. Además, los 'variable_datatype' empiezan con mayúscula (p. ej., Int empieza por 'I'), lo que indica que todos los tipos anteriores son objetos en Scala.

Reglas para definir variables en Scala

Las reglas y convenciones para definir variables en Scala son:

1. El nombre de la variable usa lower camel case. Por ejemplo, en 'nameOfGirl', la 'n' inicial va en minúscula. Después, la inicial de cada palabra compuesta va en mayúscula, como 'O' y 'G'.
2. El nombre de la variable no debe contener palabras reservadas ni palabras clave de Scala.
3. El nombre de la variable puede contener el signo dólar ('$') y el guion bajo ('_'). Sin embargo, no se permiten otros caracteres especiales como '#', '&', etc. Además, se desaconseja usar guion bajo.
4. No se permiten espacios en blanco (tabs, espacio) en el nombre de una variable.
5. El nombre de la variable debe comenzar por una letra; no puede empezar por un número ni por otros caracteres.

Variables mutables

Las variables mutables permiten cambiar su valor incluso después de haber sido declaradas.

La sintaxis de una variable mutable es la siguiente:

var variable_name : variable_datatype = value;

La sintaxis de una variable mutable también puede definirse así:

var variable_name = value;

Ejemplo de variable mutable:

var nameOfThing: String = "Car";

En el ejemplo anterior, var es la palabra clave para definir variables mutables. El nombre de la variable es 'nameOfThing'. Le sigue dos puntos con el tipo de dato 'String'. El valor almacenado en memoria será 'Car'.

El mismo ejemplo de variable mutable con otra sintaxis se puede escribir así:

var nameOfThing = "Car";

Puedes definir la variable sin indicar su tipo, como arriba. El compilador de Scala determinará automáticamente que es de tipo 'String'; a esto se le llama inferencia de tipos.

Puedes cambiar el valor de la variable fácilmente, como sigue:

nameOfThing = "Bike";
print(nameOfThing)

El valor de la variable cambiará de "Car" a "Bike". La salida será "Bike", porque la palabra clave 'var' te permite modificar el valor de la variable (Fuente: Variables in Scala).

Variables inmutables

Las variables inmutables son aquellas cuyo valor no puede cambiar una vez creadas y se declaran con la palabra clave 'val'.

La sintaxis de una variable inmutable es:

val variable_name : variable_data type = value;

La sintaxis de una variable inmutable también puede definirse así:

val variable_name = value;

Ejemplo de variable inmutable:

val numberOfThing: Int = 2;

En el ejemplo anterior, val es la palabra clave para definir variables inmutables y el nombre de la variable es 'numberOfThing'. Le sigue dos puntos con el tipo 'Int' y el valor almacenado en memoria es 2.

El mismo ejemplo de variable inmutable con otra sintaxis se puede escribir así:

val numberOfThing = 2;

Puedes definir la variable sin indicar su tipo, como arriba, y el compilador de Scala deducirá que es de tipo 'Int'. Este proceso se llama inferencia de tipos (Fuente: Variables in Scala).

No puedes cambiar el valor de la variable como sigue:

numberOfThing = 7;

El ejemplo anterior dará un error como "error: not found: value numberOfThing", lo que muestra que la reasignación de valor no es posible, como se ve a continuación:

Declaraciones y asignaciones múltiples

En Scala se pueden hacer declaraciones múltiples usando la palabra clave 'var', con los nombres de las variables separados por comas y el signo "=" con el valor correspondiente.

var (x, y, z) = (5, 4.5, "Sit")

En el ejemplo anterior, puedes ver que las variables x, y y z reciben los valores 5, 4.5 y "Sit", respectivamente, como sigue.

También puedes realizar asignaciones múltiples en una sola línea usando 'val', con los nombres de las variables separados por comas y el signo "=" con el valor para la variable.

val a, b, c = 1;

En el ejemplo anterior, las variables a, b y c reciben el valor 1, como se muestra.

Ámbito de una variable

El ámbito es la visibilidad de las variables y su tiempo de vida dentro de los bloques de código definidos. Una variable puede estar en ámbito local o global. Por ejemplo:

var globalVar = 10
def sub(){
var difference = 9-4;
}
print(difference)//Error
print(globalVar)//Valid

En el código anterior, la variable 'difference' está en el ámbito local porque se declara dentro del método 'sub'. La operación de resta será válida, pero imprimir su valor fuera del método 'sub' provocará un error. También hay un ámbito global, donde la variable 'globalVar' puede accederse desde cualquier parte del programa y se le pueden aplicar operaciones.

Hay tres tipos de ámbito para variables en Scala (Fuente: Scala- Variables):

1. Variables locales
2. Campos
3. Parámetros de método

Variables locales

Las variables locales, ya sean mutables o inmutables, se declaran dentro de un método y solo son accesibles dentro de ese método, no fuera.

Puedes ver este ejemplo sencillo sobre variables locales:

class Perimeter  
{
    def triangle()  
    {
        var side1 = 10;
        var side2 = 20;
        var side3 = 30;

        var total = side1+side2+side3;
        print("Perimeter of the  triangle is: " + total);
    }
}

object Test  
{

    def main(args:Array[String])  
    {
        val p1 = new Perimeter()
        p1.triangle()
    }
}

defined class Perimeter
defined object Test

El código anterior devuelve:

The perimeter of the triangle is: 60

El programa contiene una clase llamada 'Perimeter' y un objeto 'Test', con un método 'triangle' que tiene tres variables mutables: side1, side2 y side3. El cálculo y la impresión del resultado se realizan dentro del método, lo que produce la salida correcta.

Campos

Las variables definidas dentro de la clase se conocen como campos y pueden ser mutables o inmutables. El modificador de acceso será público automáticamente si la variable se declara dentro de la clase pero no dentro de ningún método; en ese caso, la variable es accesible desde cualquier parte del programa. En cambio, una variable privada puede accederse dentro de la clase donde se define, pero no fuera de su ámbito, ni siquiera desde el objeto.

class FieldExample
{
  var value1 = 10;
  private var value2 = 30;
  def operation()
  {
    println("Value of value1:"+value1)
  }
  println("Value of value2: "+value2);
}

object Demo
{
  def Main(args:Array[String])
  {
    val obj = new FieldExample()
    obj.operation()
    print(obj.value1)//Valid
    print(obj.value2)


  }
}

defined class FieldExample
defined object Demo

El código anterior devuelve:

Value of value2: 30
Value of value1:10
10

El programa contiene una clase 'FieldExample', un objeto 'Demo' y un método 'operation'. La variable pública value1 se puede acceder con notación de punto y su valor impreso es 10. La variable privada value2 vale 30; intentar acceder a ella e imprimirla desde fuera provocará un error.

Parámetros de método

Los parámetros de método son variables que reciben un valor cuando se invoca el método, y la variable es inmutable, ya que se define con la palabra clave 'val'. Además, la variable puede accederse fuera del método cuando se hace una referencia a ella.

Puedes ver este ejemplo sencillo sobre parámetros de método:

class Triangle
{
    def calculate(height: Int, width: Int)
    {
        var result = 0.5*(height+width);
        println("Area of triangle is: " + result);
    }
}

object Area  
{
     def main(args:Array[String])
    {
        val a = new Triangle()
        a.calculate(4,5);
    }
}

defined class Triangle
defined object Area

El código anterior devuelve:

Area of triangle is: 4.5

El programa contiene una clase 'Triangle'. Incluye un método 'calculate' con dos parámetros de método, height y width. Los valores enteros 4 y 5 se pasan cuando se llama a 'calculate' usando la instancia de objeto a.

Conclusión

¡Enhorabuena, has llegado al final de este tutorial!

En este tutorial has visto las variables de Scala, las reglas para definirlas, los distintos tipos de variables, cómo hacer declaraciones y asignaciones múltiples y cómo funciona su ámbito.

Si quieres saber más sobre Scala, haz el curso de DataCamp Introduction to Scala.