Variabili in Scala

Dai un'occhiata al corso Scala appena lanciato da DataCamp: Introduction to Scala.

Scala è ampiamente usato dai data scientist quando lavorano con grandi volumi di dati insieme ad Apache Spark nel campo del Big Data. È un linguaggio di programmazione sia orientato agli oggetti sia funzionale, con molte altre caratteristiche essenziali elencate di seguito:

1. Scala è noto per essere un linguaggio tipizzato staticamente, in cui il tipo di dato della variabile è definito prima che venga usata. Il controllo del tipo avviene in fase di compilazione, non a runtime.
2. È anche un linguaggio "fortemente tipizzato" in cui le variabili vengono controllate prima di eseguire un'operazione su di esse.
3. Supporta inoltre l'inferenza dei tipi, in cui il compilatore deduce il tipo dall'espressione o dai letterali, quindi dichiarare esplicitamente il tipo della variabile è opzionale.

In questo tutorial, tratterai i seguenti argomenti:

• Variabili
• Regole per definire le variabili in Scala
• Variabili mutabili
• Variabili immutabili
• Dichiarazioni e assegnazioni multiple
• Ambito delle variabili in Scala

Variabili

Le variabili sono uno spazio nominato in memoria, e il compilatore alloca una posizione riservata in base al tipo di dato della variabile corrispondente. In Scala la variabile si dichiara con la seguente sintassi:

val or val variable_name: variable_datatype = value;

Nella sintassi sopra, la variabile può essere definita in due modi usando la parola chiave 'var' o 'val'. È composta da 'variable_name' come nuova variabile, seguito da due punti. Il tipo di dato della variabile è 'variable_datatype', che può essere qualsiasi tipo valido. Dopo di che, il 'value' viene assegnato a 'variable_name'.

Per esempio:

val varValue: Byte = 8;

'val' è la parola chiave per definire la variabile, e 'varValue' è il nome della variabile. È di tipo 'Byte' e contiene il valore 8. 'Byte' è un valore con segno a 8 bit, che va da 2⁻⁷ a 2⁷−1.

Il 'variable_datatype' sopra può essere di qualsiasi tipo di dato esistente in Scala, come segue.

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

Allo stesso modo, altri tipi di dato come Long, Char, Boolean, Char, String, Boolean, Null hanno ognuno il proprio intervallo, e una spiegazione dettagliata è fornita nel tutorial Beginner’s Guide to Scala. Inoltre, 'variable_datatype' dovrebbe iniziare con una lettera maiuscola, cioè Int contiene la 'I', il che indica che tutti i tipi di dato sopra sono oggetti in Scala.

Regole per definire le variabili in Scala

Le regole e le convenzioni per definire le variabili in Scala sono le seguenti:

1. Il nome della variabile inizia con lower camel case. Per esempio, nel nome della variabile 'nameOfGirl', 'n' è minuscola. In seguito, metti in maiuscolo l'iniziale di ogni parola come 'O' e 'G'.
2. Il nome della variabile non deve contenere parole riservate o keyword definite in Scala.
3. Il nome della variabile può contenere il simbolo del dollaro ('$') e il trattino basso ('_'). Tuttavia, altri caratteri speciali come '#','&', ecc. non sono consentiti. Inoltre, l'uso del trattino basso è sconsigliato.
4. Gli spazi bianchi (tab, spazio) non sono consentiti in un nome di variabile.
5. Il nome della variabile deve iniziare con una lettera e non può iniziare con un numero o altri caratteri.

Variabili mutabili

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

La sintassi di una variabile mutabile è mostrata di seguito:

var variable_name : variable_datatype = value;

La sintassi di una variabile mutabile può anche essere definita come segue:

var variable_name = value;

L'esempio di variabile mutabile è mostrato di seguito:

var nameOfThing: String = "Car";

Nell'esempio sopra è presente var come parola chiave, usata per definire variabili mutabili. Il nome della variabile è 'nameOfThing'. È seguito da due punti con il tipo di dato della variabile 'String'. Il suo valore memorizzato in memoria sarà 'Car'.

Lo stesso esempio di variabile mutabile con sintassi diversa può essere scritto così:

var nameOfThing = "Car";

Puoi definire la variabile senza specificarne il tipo, come fatto sopra. Il compilatore Scala lo determina automaticamente come tipo 'String', processo chiamato inferenza dei tipi.

Puoi cambiare facilmente il valore della variabile come segue:

nameOfThing = "Bike";
print(nameOfThing)

Il valore della variabile cambierà da "Car" a "Bike". L'output sarà "Bike", perché la parola chiave 'var' ti permette di modificare il valore della variabile (Fonte: Variables in Scala).

Variabili immutabili

Le variabili immutabili sono quelle il cui valore non può essere cambiato una volta creato e si dichiarano usando la parola chiave 'val'.

La sintassi della variabile immutabile è mostrata di seguito:

val variable_name : variable_data type = value;

La sintassi della variabile immutabile può anche essere definita come segue:

val variable_name = value;

L'esempio di variabile immutabile è mostrato di seguito:

val numberOfThing: Int = 2;

Nell'esempio sopra è presente val come parola chiave per definire variabili immutabili e il nome della variabile è 'numberOfThing'. È seguito da due punti con il tipo di dato 'Int' e il valore memorizzato in memoria è 2.

Lo stesso esempio di variabile immutabile con sintassi diversa può essere scritto così:

val numberOfThing = 2;

Puoi definire la variabile senza specificarne il tipo, come fatto sopra, dove il compilatore Scala lo deduce automaticamente come tipo 'Int'. Il processo si chiama inferenza dei tipi (Fonte: Variables in Scala).

Non puoi cambiare il valore della variabile come qui sotto:

numberOfThing = 7;

L'esempio sopra produrrà un errore del tipo "error: not found: value numberOfThing", che mostra che la riassegnazione del valore non è possibile come illustrato di seguito:

Dichiarazioni e assegnazioni multiple

In Scala sono possibili dichiarazioni multiple usando la parola chiave 'var' con i nomi delle variabili separati da virgole e il segno "=" con il valore per la variabile.

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

Nell'esempio sopra, puoi vedere che tutte le variabili x, y e z vengono assegnate rispettivamente ai valori 5, 4.5 e "Sit" come segue.

Le assegnazioni multiple sono possibili in Scala in un'unica riga usando la parola chiave 'val' con i nomi delle variabili separati da virgole e il segno "=" con il valore per la variabile.

val a, b, c = 1;

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

Ambito di una variabile

L'ambito è la visibilità delle variabili, che hanno un ciclo di vita all'interno dei blocchi di codice specificati. La variabile può essere definita in ambito locale o globale. Per esempio:

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

Nel codice sopra, la variabile 'difference' è in ambito locale perché è dichiarata dentro il metodo 'sub', e l'operazione di sottrazione darà risultati validi, ma stamparne il valore fuori dal metodo 'sub' causerà un errore. Esiste anche un ambito globale in cui la variabile 'globalVar' può essere accessibile ovunque nel programma e su di essa si può eseguire qualsiasi operazione.

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

1. Variabili locali
2. Campi
3. Parametri di metodo

Variabili locali

Le variabili locali sono variabili mutabili o immutabili dichiarate all'interno di un metodo e accessibili solo all'interno dei metodi, ma non all'esterno.

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:

The perimeter of the triangle is: 60

Il programma sopra contiene una classe chiamata 'Perimeter' e un oggetto 'Test' in cui c'è un metodo chiamato triangle con tre variabili mutabili: side1, side2, side3. Il calcolo e la stampa del risultato verranno eseguiti all'interno del metodo, producendo l'output corretto.

Campi

Le variabili definite all'interno della classe sono note come variabili di campo e possono essere di qualsiasi tipo, sia mutabili che immutabili. Il modificatore di accesso sarà automaticamente pubblico se la variabile è dichiarata all'interno della classe ma non deve essere definita dentro alcun metodo, così la variabile è accessibile ovunque nel programma. Tuttavia, una variabile privata può essere accessibile all'interno della classe definita ma non può essere accessibile al di fuori dell'ambito della classe, né nell'oggetto.

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 sopra dà il risultato:

Value of value2: 30
Value of value1:10
10

Il programma sopra contiene una classe chiamata 'FieldExample', un oggetto 'Demo' e un metodo 'operation'. La variabile pubblica value1 può essere accessibile usando la notazione a punti e il valore stampato è 10. La variabile privata value2 vale 30: accedervi e stamparla causerà un errore.

Parametri di metodo

I parametri di metodo sono variabili che accettano il valore quando il metodo viene chiamato, e la variabile deve essere immutabile, definita usando la parola chiave 'val'. Inoltre, la variabile può essere accessibile all'esterno del metodo quando ne viene fatto riferimento.

Puoi vedere l'esempio semplice qui sotto per conoscere i parametri di 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 sopra dà il risultato:

Area of triangle is: 4.5

Il programma sopra contiene una classe chiamata 'Triangle'. Include un metodo chiamato 'calculate' con due parametri di metodo height e width. I valori interi 4 e 5 vengono passati quando 'calculate' è chiamato usando l'istanza di oggetto a.

Conclusione

Congratulazioni, sei arrivato alla fine di questo tutorial!

In questo tutorial, hai visto le variabili di Scala, le regole per definirle, i diversi tipi di variabili con dichiarazioni e assegnazioni multiple, insieme all'ambito delle variabili.

Se vuoi saperne di più su Scala, segui il corso di DataCamp Introduction to Scala.