Variables en Scala

Prueba el recientemente lanzado curso de Scala en DataCamp: Introducción a Scala.

Scala es ampliamente utilizado por científicos de datos al manejar los grandes volúmenes de datos utilizados junto con Apache Spark en el campo de Big Data. Es un lenguaje tanto orientado a objetos como funcional con muchas otras características esenciales listadas a continuación:

1. Scala se conoce como un lenguaje con tipado estático, donde el tipo de dato para la variable se define antes de su uso. La comprobación de tipo se realiza en tiempo de compilación en lugar de en tiempo de ejecución.
2. También es un lenguaje “fuertemente tipado” donde las variables se verifican antes de realizar una operación en él.
3. También admite inferción de tipo, donde el compilador infiere el tipo de la expresión o literales, así que declarar el tipo de 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
• Alcance de las Variables en Scala

Variables

Las variables son un espacio nombrado en memoria, y el compilador asigna ubicaciones reservadas según el tipo de datos de la variable correspondiente. La variable se declara con la siguiente sintaxis en Scala:

val or val variable_name: variable_datatype = value;

En la sintaxis anterior, la variable se puede definir de dos maneras distintas utilizando el keyword ‘var’ o ‘val’. Consiste en ‘variable_name’ como su nueva variable, seguido de un signo de igual. El tipo de dato de la variable es ‘variable_datatype’ que puede ser cualquier tipo de dato válido. Después de eso, ‘value’, el símbolo se asigna a ‘variable_name.’

Por ejemplo:

val varValue: Byte = 8;

El ‘val’ es el keyword para definir la variable, y ‘varValue’ es el nombre de la variable. Es del tipo de dato ‘Byte’ y contiene el valor 8. ‘Byte’ es un valor de 8 bits con signo, que abarca de 2⁻⁷ a 2⁷−1.

El ‘variable_datatype’ de arriba puede ser de cualquier tipo de dato que exista en Scala y son como sigue.

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

Asimismo, otros tipos de datos como Long, Char, Boolean, Char, String, Boolean, Null tienen su propio rango, y se proporciona una explicación detallada en el tutorial Guía de principiantes para Scala. Además, la ‘variable_datatype’ debe comenzar con una letra mayúscula, es decir, Int contiene ‘I’, lo que indica que todos los tipos de datos mencionados son objetos en Scala.

Reglas que definen las variables en Scala

Las reglas y convenciones para definir variables en Scala son las siguientes:

1. El nombre de la variable comienza con una letra minúscula y en mayúscula. Por ejemplo, en el nombre de variable ‘nameOfGirl’, contiene ‘n’ como letra minúscula. Después, se pone en mayúscula la primera letra de cada palabra, como ‘O’ y ‘G’.
2. El nombre de la variable no debe contener palabras reservadas o keywords definidos en Scala.
3. El nombre de la variable puede contener el signo de dólar (‘$’) y el guión bajo (‘_’). Sin embargo, no se permiten otros caracteres especiales como ‘#’, ‘&’, etc. Además, se desaconseja el uso de guiones bajos.
4. No se permite espacio en blanco (tabulador, espacio) en el nombre de la variable.
5. El nombre de la variable debe comenzar con una letra y no puede empezar con un número o otros caracteres.

Variables mutables

Las variables mutables permiten cambiar los valores de las variables incluso después de la declaración de las variables.

La sintaxis de la variable mutable se muestra a continuación:

var variable_name : variable_datatype = value;

La sintaxis de la variable mutable puede definirse también de la siguiente manera:

var variable_name = value;

El ejemplo de la variable mutable se muestra a continuación:

var nameOfThing: String = "Car";

El ejemplo anterior contiene la palabra clave var, que se utiliza para definir variables mutables. El nombre de la variable es ‘nameOfThing’. Le sigue un signo de igual con el tipo de dato de la variable como ‘String’. Su valor almacenado en la memoria será ‘Car’.

El ejemplo anterior de variable mutable con diferentes sintaxis se puede realizar como sigue:

var nameOfThing = "Car";

Puede definir su variable sin el tipo de dato de la variable, como se ha hecho arriba. El compilador de Scala determina automáticamente que sea un tipo de dato ‘String’, lo que se denomina Inferencia de tipo.

Puede cambiar fácilmente el valor de la variable, como se muestra a continuación:

nameOfThing = "Bike";
print(nameOfThing)

El valor de la variable cambiará de “Car” a “Bike”. La salida será “Bike”, ya que la palabra clave ‘var’ permite cambiar el valor de la variable (Fuente: Variables en Scala).

Variables inmutables

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

La sintaxis de la variable inmutable se muestra a continuación:

val variable_name : variable_data type = value;

La sintaxis de la variable inmutable también se puede definir de la siguiente manera:

val variable_name = value;

El ejemplo de la variable inmutable se muestra a continuación:

val numberOfThing: Int = 2;

Los siguientes ejemplos contienen `val` como palabra clave para definir variables inmutables y el nombre de una variable como ‘numberOfThing’. Le sigue una coma con el tipo de datos de la variable como ‘Int’ junto con el valor almacenado en memoria que es 2.

El ejemplo anterior de variable inmutable con una sintaxis diferente se puede hacer como sigue:

val numberOfThing = 2;

Puede definir su variable sin el tipo de datos de la variable como se hizo arriba, donde el compilador de Scala lo determina automáticamente como un tipo de datos ‘Int’. El proceso se llama Inferencia de Tipo (Fuente: Variables en Scala).

No puede cambiar el valor de la variable como se muestra a continuación:

numberOfThing = 7;

El ejemplo anterior resultará en un error como “error: no se encontró el valor numberOfThing”, lo que muestra que la reasignación de valor no es posible como se muestra a continuación:

Declaraciones Múltiples y Asignaciones

Las declaraciones múltiples pueden ser posibles en Scala usando la palabra clave ‘var’ con el nombre de la variable separado por comas y el signo “=” con el valor de la variable.

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

En el ejemplo anterior, se puede ver que todas las variables x, y, y z se asignan al valor 5, 4.5 y “Sit” respectivamente como sigue.

Las asignaciones múltiples pueden ser posibles en Scala en una sola línea usando la palabra clave ‘val’ con el nombre de la variable separado por comas y el signo “=” con el valor de la variable.

val a, b, c = 1;

En el ejemplo anterior, se puede ver que todas las variables a, b, y c se asignan al valor 1 como sigue.

Ámbito de una Variable

El alcance es la visibilidad de las variables que tienen su ciclo de vida dentro de los bloques especificados del código. La variable puede ser definida en el Alcance Local o Global. Por ejemplo:

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

En el código de arriba, la variable ‘difference’ está en el Alcance Local donde es declarada dentro del método ‘sub’. La operación de resta dará resultados válidos, pero imprimir el valor fuera del método ‘sub’ causará un error. También existe un Alcance Global en el que se puede acceder a la variable ‘globalVar’ en cualquier parte del programa, y se puede realizar cualquier operación a él.

Hay tres tipos de alcance para las variables en Scala (Fuente: Scala- Variables):

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

Variables locales

Las variables locales son mutables o inmutables que son declaradas dentro de un método y solo pueden ser accesibles dentro de los métodos y no fuera de ellos.

Puede ver el ejemplo simple de abajo para saber sobre las 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 de arriba da el resultado:

El perímetro del triángulo es: 60

El programa de arriba contiene una clase llamada ‘Perimeter’ y un objeto ‘Test’ donde hay un método llamado triángulo que tiene tres variables mutables como side1, side2, side3. La calculación y la impresión del resultado se harán dentro del método, lo que dará el resultado correcto.

Campos

Esos variables definidas dentro de la clase se conocen como variables de campo, que pueden ser de cualquier tipo, variables mutables o inmutables. El modificador de acceso será automáticamente público si la variable es declarada dentro de la clase pero no debe estar definida dentro de ningún método donde la variable sea accesible en cualquier parte del programa. Sin embargo, una variable privada puede ser accedida dentro de la clase definida pero no puede ser accedida fuera del ámbito de la clase o incluso en el objeto también.

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 da el resultado:

Valor de value2: 30
Valor de value1:10
10

El programa anterior contiene una clase llamada ‘FieldExample’, el objeto es ‘Demo’ y un método es ‘operation’. La variable pública value1 puede ser accedida usando la notación de punto, y el valor se imprime como 10. La variable privada value2 es 30, donde acceder a esa variable e imprimirla provocará un error.

Parámetros de Método

Los parámetros de método son las variables que aceptan el valor cuando se llama al método, y la variable debe ser mutable, que se define usando la palabra clave ‘val’. Además, la variable puede ser accedida fuera del método cuando se hace una referencia a ella.

Puede ver un ejemplo sencillo a continuación para conocer los 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 da el resultado:

El área del triángulo es: 4.5

El programa de arriba contiene una clase llamada ‘Triangle.’ Incluye un método llamado ‘calculate’ con dos parámetros de método altura y anchura. Los valores enteros 4 y 5 se pasan cuando se llama a ‘calculate’ usando la instancia de objeto a.

Conclusión

Felicidades, has llegado al final de este tutorial!

En este tutorial, has cubierto sobre las variables de Scala, las reglas para definir variables, diferentes tipos de variables con declaración y asignaciones múltiples junto con el ámbito de variable en él.

Si te gustaría aprender más sobre Scala, toma el curso de DataCamp Introducción a Scala.