Variabili in Scala

Introduzione a Scala.

Scala è ampiamente utilizzato dai data scientist quando si tratta di gestire grandi volumi di dati usati insieme ad Apache Spark nel campo dei Big Data. È un linguaggio di programmazione sia orientato agli oggetti che funzionale con molte altre caratteristiche essenziali elencate di seguito:

1. Scala è noto per essere un linguaggio a tipizzazione statica, in cui il tipo di dati per la variabile viene definito prima del suo utilizzo. Il controllo del tipo avviene durante la compilazione piuttosto che durante l’esecuzione.
2. È anche un linguaggio “Fortemente Tipizzato” in cui le variabili vengono controllate prima di eseguire un’operazione.
3. Supporta anche l’Inferenza di Tipo, in cui il compilatore deduce il tipo dall’espressione o dai letterali, quindi dichiarare il tipo di variabile è opzionale.

In questo tutorial, si copriranno i seguenti argomenti:

• Variabili
• Regole per la definizione delle Variabili in Scala
• Variabili mutevole
• Variabili immutabili
• Declarations e Assegnazioni Multiple
• Scopo delle Variabili in Scala

Variabili

Le variabili sono spazi in memoria con un nome, e il compilatore alloca posizioni riservate in base al tipo di dati corrispondente. In Scala, le variabili vengono dichiarate con la seguente sintassi:

val or val variable_name: variable_datatype = value;

Nella sintassi sopra, le variabili possono essere definite in due modi, utilizzando i keyword ‘var’ o ‘val’. Si compone di ‘nome_variabile’ come la nuova variabile, seguito da un colon. Il tipo di dato della variabile è ‘tipo_dato_variabile’, che può essere qualsiasi tipo di dato valido. Dopo di che, il simbolo ‘valore’ viene assegnato a ‘nome_variabile’.

Per esempio:

val varValue: Byte = 8;

‘val’ è il keyword per definire la variabile, e ‘varValue’ è il nome della variabile. È di tipo ‘Byte’ e contiene il valore 8. ‘Byte’ è un valore firmato a 8 bit, che va da 2⁻⁷ a 2⁷−1.

‘tipo_dato_variabile’ sopra può essere di qualsiasi tipo di dato esistente in Scala ed è come segue.

1. Int: È un valore firmato a 32 bit (valore positivo o negativo), che ha un intervallo da 2⁻³¹ a 2³¹−1.
2. Byte: È un valore firmato a 8 bit che ha un intervallo da 2⁻⁷ a 2⁷−1.
3. Short: È un valore firmato a 16 bit che va da 2⁻¹⁵ a 2¹⁵−1.
4. Float: Può essere sia a 32 bit che a 64 bit.

Analogamente, altri tipi di dato come Long, Char, Boolean, Char, String, Boolean, Null hanno il loro range e viene fornita una spiegazione dettagliata nel tutorial Beginner’s Guide to Scala. Inoltre, il ‘variable_datatype’ dovrebbe iniziare con una lettera maiuscola, ad esempio, Int contiene ‘I’, che indica che tutti i tipi di dato sopra sono oggetti in Scala.

Regole per la definizione delle variabili in Scala

Le regole e le convenzioni per la definizione delle variabili in Scala sono le seguenti:

1. Il nome della variabile inizia con una lettera minuscoletto. Ad esempio, nel nome della variabile ‘nameOfGirl,’ contiene ‘n’ come minuscola. Successivamente, si mettono in maiuscolo le prime lettere di ogni parola, come ‘O’ e ‘G’.
2. Il nome della variabile non deve contenere parole riservate o keyword definiti in Scala.
3. Il nome della variabile può contenere il simbolo dollaro (‘$’) e il sottolineato (‘_’). Tuttavia, altri caratteri speciali come ‘#’,’&’, ecc., non sono permessi. Anche l’uso dell’underscore è scoraggiato.
4. Non è consentito nessun spazio (tabs, spazi) nel nome della variabile.
5. Il nome della variabile deve iniziare con una lettera e non può iniziare con un numero o altri caratteri.

Variabili Mutable

Le variabili mutabili consentono di cambiare i valori delle variabili anche dopo la dichiarazione delle stesse.

La sintassi della variabile mutabile è mostrata qui sotto:

var variable_name : variable_datatype = value;

La sintassi dell’attributo mutabile può anche essere definita come segue:

var variable_name = value;

L’esempio dell’attributo mutabile è mostrato qui sotto:

var nameOfThing: String = "Car";

L’esempio precedente contiene la parola chiave var, utilizzata per definire gli attributi mutabili. Il nome dell’attributo è ‘nameOfThing’. Segue una virgola con il tipo di dato dell’attributo, ‘String’. Il suo valore memorizzato in memoria sarà ‘Car’.

L’esempio precedente di attributo mutabile con una sintassi diversa può essere riportato come segue:

var nameOfThing = "Car";

Puoi definire la tua variabile senza specificare il tipo di dato, come fatto qui sopra. Il compilatore Scala lo determineraà automaticamente come tipo ‘String’, detto anche Inferenza del tipo.

Puoi facilmente cambiare il valore della variabile, come mostrato qui sotto:

nameOfThing = "Bike";
print(nameOfThing)

Il valore dell’attributo cambierà da “Car” a “Bike”. L’output sarà “Bike”, poiché la parola chiave ‘var’ ti permette di cambiare il valore dell’attributo (fonte: Variabili in Scala).

Variabili immutabili

Le variabili immutabili sono quelle la cui values non può essere cambiato una volta create e sono dichiarate utilizzando la parola chiave ‘val’.

La sintassi della variabile immutabile è mostrata qui sotto:

val variable_name : variable_data type = value;

La sintassi dell’attributo immutabile può anche essere definita come segue:

val variable_name = value;

L’esempio dell’attributo immutabile è mostrato qui sotto:

val numberOfThing: Int = 2;

L’esempio precedente include val come una parola chiave per la definizione di variabili immutabili e il nome di una variabile come ‘numberOfThing’. Viene seguito da un punto e virgola con il tipo di dato della variabile come ‘Int’ insieme al valore memorizzato in memoria, che è 2.

L’esempio precedente di una variabile immutabile con una sintassi diversa può essere fatto come segue:

val numberOfThing = 2;

Puoi definire la tua variabile senza il tipo di dato della variabile, come fatto qui sopra, dove il compilatore di Scala lo identifica automaticamente come un tipo di dato ‘Int’. Il processo è chiamato Inference del tipo (Fonti: Variabili in Scala).

Non puoi cambiare il valore della variabile come mostrato qui sotto:

numberOfThing = 7;

L’esempio precedente genererà un errore come “errore: non trovato: valore numberOfThing”, che mostra che la riassegnazione del valore non è possibile come mostrato qui sotto:

Multiple Declarations and Assignments

Le dichiarazioni multiple sono possibili in Scala usando la parola chiave ‘var’ con il nome delle variabili separate da virgole e il segno “=” con il valore per la variabile.

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

Nell’esempio precedente, puoi vedere che tutte le variabili x, y e z vengono assegnate ai valori 5, 4.5 e “Sit” rispettivamente come segue.

Le assegnazioni multiple sono possibili in Scala in una riga usando la parola chiave ‘val’ con il nome delle variabili separate da virgole e il segno “=” con il valore per la variabile.

val a, b, c = 1;

Nell’esempio precedente, puoi vedere che tutte le variabili a, b e c vengono assegnate al valore 1 come segue.

Scope of a Variable

L’ambito è la visibilità delle variabili la cui durata di vita è all’interno dei blocchi di codice specificati. La variabile può essere definita in Ambito Locale o Globale. Ad esempio:

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

Nel codice sopra, la variabile ‘differenza’ è in Ambito Locale dove è dichiarata all’interno del metodo ‘sub’, e l’operazione di sottrazione darà risultati validi, ma stampare il valore al di fuori del metodo ‘sub’ causerà un errore. C’è anche un Ambito Globale dove la variabile ‘globalVar’ può essere accessibile ovunque nel programma, e qualsiasi operazione può essere eseguita su di essa.

Ci sono tre tipi di ambito per le variabili in Scala (Fonte: Scala- Variables):

1. Variabili Locali
2. Campi
3. Parametri del Metodo

Variabili Locali

Le variabili locali sono variabili mutabili o immutabili che sono dichiarate all’interno di un metodo e possono essere accessibili solo all’interno dei metodi ma non al di fuori di essi.

Puoi vedere l’esempio semplice qui sotto per conoscere le variabili locali:

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

Il codice sopra dà il risultato:

Il perimetro del triangolo è: 60

Il programma sopra contiene una classe chiamata ‘Perimetro’ e un oggetto chiamato ‘Test’ dove c’è un metodo chiamato triangolo che ha tre variabili mutabili come lato1, lato2, lato3. Il calcolo e la stampa del risultato saranno eseguiti all’interno del metodo, il che darà l’output corretto.

Campi

Le variabili definite all’interno della classe sono note come campi di classe, che possono essere di qualsiasi tipo, sia variabili mutabili che immutabili. L’accessibilità della variabile sarà automaticamente pubblica se la variabile è definita all’interno della classe, ma non dovrebbe essere definita all’interno di alcun metodo in cui la variabile è accessibile da qualsiasi punto del programma. Tuttavia, una variabile privata può essere accessibile all’interno della classe definita ma non può essere accessibile fuori dalla portata della classe o neanche nell’oggetto stesso.

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

Il codice soprastante dà il risultato:

Value of value2: 30
Value of value1:10
10

Il programma soprastante contiene una classe chiamata ‘FieldExample,’ un oggetto chiamato ‘Demo’ e un metodo chiamato ‘operation.’ La variabile pubblica value1 può essere accessibile usando la notazione punto e il suo valore è stampato come 10. La variabile privata value2 è di valore 30, accessibile solo all’interno della classe e non può essere accessibile esternamente o nell’oggetto.

Parametri Metodo

I parametri del metodo sono le variabili che accettano un valore quando il metodo viene chiamato, e la variabile deve essere mutabile, definita usando il keyword ‘val’. Anche la variabile può essere accessibile esternamente quando viene creata una referenza a essa.

Puoi vedere l’esempio semplice qui sotto per conoscere i Parametri Metodo:

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

Il codice soprastante dà il risultato:

Area of triangle is: 4.5

Il programma sopra contiene una classe chiamata ‘Triangolo’. Include un metodo chiamato ‘calcola’ con due parametri metodo di altezza e larghezza. I valori interi 4 e 5 vengono passati quando ‘calcola’ viene chiamato utilizzando l’istanza dell’oggetto a.

Conclusione

Congratulazioni, sei arrivato alla fine di questo tutorial!

In questo tutorial, hai coperto circa le variabili di Scala, le regole per la definizione di variabili, differenti tipi di variabili con Declarazione multipla e Assegnazioni insieme alla Portata della variabile.

Se vuoi imparare di più riguardo a Scala, prendi il corso di Introduzione a Scala su DataCamp.