Variabili Go

Una variabile è una posizione di memorizzazione utilizzata per conservare un valore, consentendo al valore memorizzato di cambiare dinamicamente durante l'esecuzione. Ogni volta che si dichiara una variabile, viene allocato un blocco di memoria per memorizzare il valore del tipo corrispondente. Visita Riferimento-Variabili per maggiori dettagli.

Dichiarazione

In Go la dichiarazione del tipo è postposta. La dichiarazione di una variabile utilizza la parola chiave var. Il formato è var nomeVariabile nomeTipo. La denominazione delle variabili deve seguire le regole di denominazione degli identificatori.

var intNum int
var str string
var char byte

Quando si dichiarano più variabili dello stesso tipo, è possibile scrivere il tipo una sola volta

var numA, numB, numC int

Quando si dichiarano più variabili di tipi diversi, è possibile utilizzare () per racchiuderle. Possono esistere più ().

var (
  name    string
  age     int
  address string
)

var (
  school string
  class int
)

Se una variabile viene solo dichiarata senza assegnazione, il valore memorizzato dalla variabile è il valore zero del tipo corrispondente.

Assegnazione

L'assegnazione utilizza l'operatore =. Ad esempio

var name string
name = "jack"

È anche possibile assegnare direttamente durante la dichiarazione

var name string = "jack"

Oppure anche così

var name string
var age int
name, age = "jack", 1

Il secondo metodo richiede di specificare il tipo ogni volta. È possibile utilizzare lo zucchero sintattico fornito dal governo: inizializzazione con variabile breve. È possibile omettere la parola chiave var e il tipo postposto, lasciando che sia il compilatore a dedurre il tipo.

name := "jack" // Variabile di tipo stringa.

Sebbene non sia necessario specificare il tipo, durante l'assegnazione successiva il tipo deve rimanere coerente. Il seguente codice non supererà la compilazione.

a := 1
a = "1"

Va anche notato che l'inizializzazione con variabile breve non può utilizzare nil, perché nil non appartiene a nessun tipo e il compilatore non può dedurne il tipo.

name := nil // Non supera la compilazione

La dichiarazione con variabile breve può essere inizializzata in blocco

name, age := "jack", 1

Il modo di dichiarazione con variabile breve non può essere utilizzato per una variabile già esistente. Ad esempio

// Esempio errato
var a int
a := 1

// Esempio errato
a := 1
a := 2

Ma c'è un'eccezione, ovvero quando si assegna una vecchia variabile e si dichiara contemporaneamente una nuova variabile. Ad esempio

a := 1
a, b := 2, 2

Questo tipo di codice può superare la compilazione. La variabile a viene riassegnata, mentre b è una nuova dichiarazione.

Nel linguaggio Go c'è una regola: tutte le variabili all'interno di una funzione devono essere utilizzate. Ad esempio, il seguente codice dichiara solo una variabile, ma non la utilizza

func main() {
  a := 1
}

Allora durante la compilazione verrà segnalato un errore, indicando che questa variabile è stata dichiarata ma non utilizzata

a declared and not used

Questa regola si applica solo alle variabili all'interno delle funzioni. Per le variabili a livello di pacchetto al di fuori delle funzioni non c'è questa limitazione. Il seguente codice può superare la compilazione.

var a = 1

func main() {

}

Anonimo

È possibile utilizzare un trattino basso per indicare che non si desidera una variabile

Open(name string) (*File, error)

Ad esempio, la funzione os.Open ha due valori di ritorno. Vogliamo solo il primo, non il secondo. Possiamo scrivere come segue

file, _ := os.Open("readme.txt")

Le variabili non utilizzate non possono superare la compilazione. Quando non si desidera una variabile, è possibile utilizzare il trattino basso _ al suo posto.

Scambio

In Go, se si desidera scambiare i valori di due variabili, non è necessario utilizzare puntatori. È possibile utilizzare direttamente l'operatore di assegnazione per lo scambio. La sintassi appare molto intuitiva. Ecco un esempio

num1, num2 := 25, 36
num1, num2 = num2, num1

Anche con tre variabili è lo stesso

num1, num2, num3 := 25, 36, 49
num1, num2, num3  = num3, num2, num1

Pensa al seguente codice. Questo è un piccolo pezzo di codice per calcolare la sequenza di Fibonacci. Quali sono i valori delle tre variabili dopo il calcolo?

a, b, c := 0, 1, 1
a, b, c = b, c, a+b

La risposta è

1 1 1

Potresti chiederti perché non è

1 1 2

Dato che a è stato assegnato il valore di b, perché il risultato di a+b è ancora 1? Quando Go esegue l'operazione di assegnazione di più variabili, l'ordine è: prima calcola i valori, poi assegna. Non calcola da sinistra a destra.

a, b, c = b, c, a+b

Potresti pensare che verrà espanso come segue

a = b
b = c
c = a + b

Ma in realtà calcolerà prima i valori di a, b, c e poi li assegnerà loro. È equivalente al seguente codice

a, b, c = 1, 1, 0+1

Quando si tratta di chiamate di funzioni, questo effetto è ancora più evidente. Abbiamo una funzione sum che può calcolare il valore di ritorno di due numeri

func sum(a, b int) int {
  return a + b
}

Utilizza la funzione per aggiungere due numeri

a, b, c := 0, 1, 1
a, b, c = b, c, sum(a, b)

Il risultato non cambia. Quando si calcola il valore di ritorno della funzione sum, i suoi parametri di input sono ancora 0 e 1

1 1 1

Quindi il codice dovrebbe essere scritto separatamente in questo modo.

a, b = b, c
c = a + b

Confronto

Il confronto tra variabili ha una premessa importante: i loro tipi devono essere uguali. Nel linguaggio Go non esiste una conversione implicita di tipo. Il seguente codice non può superare la compilazione

func main() {
  var a uint64
  var b int64
  fmt.Println(a == b)
}

Il compilatore ti dirà che i tipi dei due non sono uguali

invalid operation: a == b (mismatched types uint64 and int64)

Quindi è necessario utilizzare la conversione esplicita del tipo

func main() {
  var a uint64
  var b int64
  fmt.Println(int64(a) == b)
}

Prima dei generici, le funzioni incorporate min e max fornite da Go supportavano solo numeri floating-point. Nella versione 1.21, Go ha finalmente riscritto queste due funzioni incorporate con i generici. Ora è possibile utilizzare la funzione min per confrontare il valore minimo

minVal := min(1, 2, -1, 1.2)

Utilizza la funzione max per confrontare il valore massimo

maxVal := max(100, 22, -1, 1.12)

I loro parametri supportano tutti i tipi confrontabili. I tipi confrontabili in Go sono

• Booleani
• Numeri
• Stringhe
• Puntatori
• Canali (supporta solo il giudizio di uguaglianza)
• Array i cui elementi sono di tipo confrontabile (le slice non sono confrontabili) (supporta solo il giudizio di uguaglianza) (supporta solo il confronto tra array della stessa lunghezza, perché la lunghezza dell'array fa anche parte del tipo e tipi diversi non sono confrontabili)
• Strutture i cui campi sono tutti di tipo confrontabile (supporta solo il giudizio di uguaglianza)

Oltre a ciò, è anche possibile giudicare importando la libreria standard cmp, ma supporta solo parametri di tipo ordinato. In Go i tipi ordinati incorporati sono solo numeri e stringhe.

import "cmp"

func main() {
  cmp.Compare(1, 2)
  cmp.Less(1, 2)
}

Blocchi di codice

All'interno di una funzione, è possibile stabilire un blocco di codice tramite parentesi graffe. Gli ambiti delle variabili tra i blocchi di codice sono indipendenti l'uno dall'altro. Ad esempio, il seguente codice

func main() {
  a := 1

  {
    a := 2
    fmt.Println(a)
  }

  {
    a := 3
    fmt.Println(a)
  }
  fmt.Println(a)
}

Il suo output è

2
3
1

Le variabili tra i blocchi sono indipendenti, non si interferiscono, non sono accessibili, ma sono influenzate dal blocco padre.

func main() {
  a := 1

  {
    a := 2
    fmt.Println(a)
  }

  {
    fmt.Println(a)
  }
  fmt.Println(a)
}

Il suo output è

2
1
1