Vai - Variabili

Una variabile non è altro che un nome dato a un'area di memoria che i programmi possono manipolare. Ogni variabile in Go ha un tipo specifico, che determina la dimensione e il layout della memoria della variabile, l'intervallo di valori che possono essere memorizzati all'interno di quella memoria e l'insieme di operazioni che possono essere applicate alla variabile.

Il nome di una variabile può essere composto da lettere, cifre e il carattere di sottolineatura. Deve iniziare con una lettera o un trattino basso. Le lettere maiuscole e minuscole sono distinte perché Go distingue tra maiuscole e minuscole. In base ai tipi di base spiegati nel capitolo precedente, ci saranno i seguenti tipi di variabili di base:

Suor n	Tipo e descrizione
1	byte Tipicamente un singolo ottetto (un byte). Questo è un tipo di byte.
2	int La dimensione più naturale del numero intero per la macchina.
3	float32 Un valore in virgola mobile a precisione singola.

Il linguaggio di programmazione Go consente anche di definire vari altri tipi di variabili come Enumeration, Pointer, Array, Structure e Union, di cui parleremo nei capitoli successivi. In questo capitolo ci concentreremo solo sui tipi di variabili di base.

Definizione variabile in Go

Una definizione di variabile indica al compilatore dove e quanto spazio di archiviazione creare per la variabile. Una definizione di variabile specifica un tipo di dati e contiene un elenco di una o più variabili di quel tipo come segue:

var variable_list optional_data_type;

Qui, optional_data_type è un tipo di dati Go valido che include byte, int, float32, complex64, boolean o qualsiasi oggetto definito dall'utente, ecc. e variable_listpuò essere costituito da uno o più nomi di identificatori separati da virgole. Alcune dichiarazioni valide sono mostrate qui -

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

La dichiarazione “var i, j, k;”dichiara e definisce le variabili i, j e k; che indica al compilatore di creare variabili denominate i, j e k di tipo int.

Le variabili possono essere inizializzate (assegnato un valore iniziale) nella loro dichiarazione. Il tipo di variabile viene valutato automaticamente dal compilatore in base al valore passato ad essa. L'inizializzatore è costituito da un segno di uguale seguito da un'espressione costante come segue:

variable_name = value;

Per esempio,

d = 3, f = 5;    // declaration of d and f. Here d and f are int

Per la definizione senza un inizializzatore: le variabili con durata di memorizzazione statica sono inizializzate implicitamente con nil (tutti i byte hanno valore 0); il valore iniziale di tutte le altre variabili è il valore zero del loro tipo di dati.

Dichiarazione di tipo statico in Go

Una dichiarazione di variabile di tipo statico garantisce al compilatore che è disponibile una variabile con il tipo e il nome dati in modo che il compilatore possa procedere per ulteriori compilazioni senza richiedere i dettagli completi della variabile. Una dichiarazione di variabile ha il suo significato solo al momento della compilazione, il compilatore necessita dell'effettiva dichiarazione di variabile al momento del collegamento del programma.

Esempio

Prova il seguente esempio, dove la variabile è stata dichiarata con un tipo e inizializzata all'interno della funzione principale -

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

20
x is of type float64

Dichiarazione di tipo dinamico / inferenza di tipo in Go

Una dichiarazione di variabile di tipo dinamico richiede che il compilatore interpreti il ​​tipo della variabile in base al valore passato ad essa. Il compilatore non richiede che una variabile abbia il tipo staticamente come requisito necessario.

Esempio

Prova il seguente esempio, in cui le variabili sono state dichiarate senza alcun tipo. Nota, in caso di inferenza di tipo, abbiamo inizializzato la variabiley con: = operatore, mentre x viene inizializzato utilizzando l'operatore =.

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)	
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

20
42
x is of type float64
y is of type int

Dichiarazione di variabili miste in Go

Variabili di diversi tipi possono essere dichiarate in una volta sola usando l'inferenza del tipo.

Esempio

package main

import "fmt"

func main() {
   var a, b, c = 3, 4, "foo"  
	
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Printf("a is of type %T\n", a)
   fmt.Printf("b is of type %T\n", b)
   fmt.Printf("c is of type %T\n", c)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

3
4
foo
a is of type int
b is of type int
c is of type string

I lvalues ​​e i rvalues ​​in Go

Ci sono due tipi di espressioni in Go:

• lvalue- Le espressioni che fanno riferimento a una posizione di memoria sono chiamate espressione "lvalue". Un lvalue può apparire come il lato sinistro o destro di un compito.

• rvalue- Il termine rvalue si riferisce a un valore di dati archiviato in un indirizzo in memoria. Un rvalue è un'espressione a cui non può essere assegnato un valore, il che significa che un rvalue può apparire sul lato destro ma non sinistro di un compito.

Le variabili sono i valori e quindi possono apparire sul lato sinistro di un compito. I letterali numerici sono rvalues ​​e quindi potrebbero non essere assegnati e non possono essere visualizzati sul lato sinistro.

La seguente dichiarazione è valida:

x = 20.0

La seguente dichiarazione non è valida. Genererebbe un errore in fase di compilazione -

10 = 20