Variabili
Cosa sono le variabili in Go?
Le variabili sono contenitori che memorizzano valori nella memoria del computer. In Go, ogni variabile ha un tipo specifico che determina quali valori puo contenere e quali operazioni sono permesse su di essa.
Dichiarazione con var
La parola chiave var e il modo piu esplicito per dichiarare una variabile:
package main
import "fmt"
func main() {
var nome string = "Mario"
var eta int = 30
var altezza float64 = 1.75
var attivo bool = true
fmt.Println(nome, eta, altezza, attivo)
}
Dichiarazione senza valore iniziale
Se non assegni un valore, la variabile riceve il valore zero del suo tipo:
var nome string // "" (stringa vuota)
var eta int // 0
var altezza float64 // 0.0
var attivo bool // false
fmt.Println(nome, eta, altezza, attivo)
// Output: 0 0 false
Dichiarazione senza tipo esplicito
Se fornisci un valore iniziale, Go puo inferire il tipo automaticamente:
var nome = "Mario" // tipo string inferito
var eta = 30 // tipo int inferito
var altezza = 1.75 // tipo float64 inferito
var attivo = true // tipo bool inferito
Dichiarazione breve con :=
L’operatore := e una scorciatoia per dichiarare e inizializzare una variabile. Puo essere usato solo all’interno di una funzione:
package main
import "fmt"
func main() {
nome := "Luigi"
eta := 25
altezza := 1.80
attivo := false
fmt.Println(nome, eta, altezza, attivo)
}
La dichiarazione breve e il modo piu comune per dichiarare variabili in Go. Il tipo viene sempre inferito dal valore assegnato.
// Non puoi usare := fuori da una funzione
// Questo causa un errore di compilazione:
// livello := "globale" // ERRORE
// Fuori dalle funzioni devi usare var
var livello = "globale" // Corretto
Dichiarazione multipla
Go permette di dichiarare piu variabili contemporaneamente in diversi modi:
Con var su una singola riga
var nome, cognome string = "Mario", "Rossi"
var x, y, z int = 1, 2, 3
Con un blocco var
Ideale per raggruppare dichiarazioni correlate:
var (
nome string = "Mario"
cognome string = "Rossi"
eta int = 30
altezza float64 = 1.75
)
Dichiarazione breve multipla
nome, cognome := "Mario", "Rossi"
x, y := 10, 20
larghezza, altezza := 1920, 1080
Valori zero
In Go, ogni tipo ha un valore zero predefinito. Se dichiari una variabile senza assegnare un valore, questa riceve automaticamente il valore zero del suo tipo:
package main
import "fmt"
func main() {
var i int // 0
var f float64 // 0.0
var b bool // false
var s string // "" (stringa vuota)
var p *int // nil (puntatore nullo)
fmt.Printf("int: %d\n", i)
fmt.Printf("float64: %f\n", f)
fmt.Printf("bool: %t\n", b)
fmt.Printf("string: %q\n", s)
fmt.Printf("pointer: %v\n", p)
}
I valori zero sono una caratteristica di sicurezza: in Go non esistono variabili “non inizializzate” che contengono dati casuali dalla memoria.
Inferenza di tipo
Go e un linguaggio tipizzato staticamente, ma grazie all’inferenza di tipo non e sempre necessario dichiarare esplicitamente il tipo:
package main
import "fmt"
func main() {
a := 42 // int
b := 3.14 // float64
c := "ciao" // string
d := true // bool
e := 'A' // rune (int32)
f := 2 + 3i // complex128
fmt.Printf("a: %T\n", a) // int
fmt.Printf("b: %T\n", b) // float64
fmt.Printf("c: %T\n", c) // string
fmt.Printf("d: %T\n", d) // bool
fmt.Printf("e: %T\n", e) // int32
fmt.Printf("f: %T\n", f) // complex128
}
Il verbo di formato %T stampa il tipo di una variabile, utile per il debugging.
Riassegnazione delle variabili
Una volta dichiarata, una variabile puo essere riassegnata con l’operatore = (senza i due punti):
package main
import "fmt"
func main() {
contatore := 0
fmt.Println(contatore) // 0
contatore = 1
fmt.Println(contatore) // 1
contatore = contatore + 10
fmt.Println(contatore) // 11
// Non puoi riassegnare un tipo diverso
// contatore = "ciao" // ERRORE: cannot use "ciao" as int
}
Attenzione: non puoi usare := per una variabile gia dichiarata nello stesso scope, a meno che non stia dichiarando almeno una nuova variabile:
x := 10
// x := 20 // ERRORE: no new variables on left side of :=
x, y := 20, 30 // OK: y e una nuova variabile
fmt.Println(x, y)
Il blank identifier _
Il blank identifier _ e un identificatore speciale che scarta un valore. E utile quando una funzione restituisce piu valori e non ti servono tutti:
package main
import (
"fmt"
"strings"
)
func main() {
// strings.Cut restituisce due parti e un booleano
prima, _, trovato := strings.Cut("ciao-mondo", "-")
fmt.Println(prima, trovato) // ciao true
// Ignora l'indice in un range
colori := []string{"rosso", "verde", "blu"}
for _, colore := range colori {
fmt.Println(colore)
}
// Ignora un errore (non consigliato in produzione)
valore, _ := fmt.Println("test")
_ = valore // scarta anche il valore se non serve
}
Il blank identifier e anche utile per verificare che un tipo implementi un’interfaccia a tempo di compilazione:
// Verifica a compile-time che MioTipo implementa l'interfaccia
var _ MiaInterfaccia = (*MioTipo)(nil)
Scope delle variabili
Le variabili in Go hanno uno scope (ambito di visibilita) definito dal blocco in cui sono dichiarate:
package main
import "fmt"
var globale = "visibile ovunque nel pacchetto"
func main() {
locale := "visibile solo in main"
if true {
interna := "visibile solo nel blocco if"
fmt.Println(globale, locale, interna)
}
// fmt.Println(interna) // ERRORE: interna non e definita qui
fmt.Println(globale, locale)
}
Conclusione
Le variabili in Go sono dichiarate con var o con la sintassi breve :=. Ogni variabile ha un tipo specifico e un valore zero predefinito. L’inferenza di tipo semplifica le dichiarazioni, il blank identifier _ permette di scartare valori non necessari e le regole di scope garantiscono un controllo preciso sulla visibilita. Queste caratteristiche rendono la gestione delle variabili in Go sicura ed efficiente.