Variabili in Golang: var, :=, valori zero e shadowing

Go ha due modi per dichiarare una variabile: var, che funziona ovunque, e :=, una forma breve che funziona dentro le funzioni e deduce il tipo.

package main

import "fmt"

func main() {
	var city string = "Lisbon" // explicit type and value
	var year = 2026            // type inferred as int
	var score int              // no value: zero value 0
	name := "Ana"              // short declaration, inferred string

	fmt.Println(city, year, score, name)
	fmt.Printf("%T %T %T %T\n", city, year, score, name)
}

Ogni variabile ha un tipo fisso deciso in fase di compilazione. Quando fornisci un valore, Go ne deduce il tipo, quindi scrivere anche il tipo (var city string = "Lisbon") è valido ma ridondante.

var e :=

La scelta idiomatica dentro una funzione:

• x := value quando hai un valore di partenza.
• var x T quando vuoi il valore zero, che segnala "vuoto di proposito": var buf bytes.Buffer, var total int.
• var x T = value quando il tipo dedotto non è quello che vuoi, per esempio var ratio float64 = 1 (un semplice ratio := 1 sarebbe un int).

:= fuori da una funzione è un errore di sintassi:

./main.go:5:1: syntax error: non-declaration statement outside function body

Valori zero

Una variabile dichiarata senza un valore non contiene mai dati casuali. Contiene il valore zero del suo tipo:

package main

import "fmt"

type Point struct {
	X, Y int
}

func main() {
	var i int
	var f float64
	var b bool
	var s string
	var p *int
	var sl []int
	var m map[string]int
	var pt Point

	fmt.Println(i, f, b, s == "", p, sl == nil, m == nil, pt)
	fmt.Println(len(sl), len(m), m["missing"])
}

Le buone API Go sono progettate in modo che il valore zero sia utile: un sync.Mutex a zero è sbloccato, un bytes.Buffer a zero è vuoto e pronto, e len, range e append funzionano tutti su uno slice nil. Quella a cui fare attenzione è la mappa: leggere da una mappa nil restituisce valori zero, ma scriverci va in panic. Crea le mappe con make o con un letterale prima di memorizzarci qualcosa.

Dichiarare più variabili

package main

import "fmt"

var (
	appName = "inventory"
	version = "1.4.0"
	debug   bool
)

func main() {
	var width, height int = 1920, 1080
	x, y := 3, 4
	first, count := "widget", 12

	fmt.Println(appName, version, debug)
	fmt.Println(width, height, x, y, first, count)

	// swap without a temporary variable
	x, y = y, x
	fmt.Println("after swap:", x, y)
}

Il blocco var ( ... ) raggruppa variabili a livello di pacchetto correlate tra loro. In un'assegnazione multipla come x, y = y, x, ogni espressione a destra viene valutata prima di qualsiasi assegnazione, ed è per questo che lo scambio funziona.

:= con più nomi non ridichiara nulla finché almeno uno dei nomi a sinistra è nuovo. I nomi già esistenti nello stesso scope vengono semplicemente assegnati. È questo che ti permette di riusare err:

f, err := os.Open("a.txt")   // declares f and err
g, err := os.Open("b.txt")   // declares g, assigns to the existing err

Se nessuno dei nomi è nuovo, è un errore:

./main.go:7:4: no new variables on left side of :=

Usa un semplice = per assegnare un valore a una variabile che esiste già.

Le variabili inutilizzate sono errori

Una variabile locale dichiarata ma mai letta blocca la build:

./main.go:9:2: declared and not used: x

Non è un avviso che puoi disattivare. Elimina la variabile, usala oppure, durante il debug, zittiscila con l'identificatore vuoto: _ = x. L'identificatore vuoto scarta anche i valori restituiti che non ti servono: _, err := fmt.Println("hi").

Le variabili a livello di pacchetto e i parametri delle funzioni sono esenti da questa regola.

Scope e shadowing

Una variabile esiste dalla sua dichiarazione fino alla fine del blocco che la contiene ({ ... }). Un := in un blocco interno crea una nuova variabile, anche se fuori ne esiste una con lo stesso nome. Quella esterna viene nascosta, non modificata:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	count := 0
	input := "42"

	if input != "" {
		count, err := strconv.Atoi(input) // new count, only inside this block
		if err != nil {
			fmt.Println("error:", err)
			return
		}
		fmt.Println("inside:", count)
	}

	fmt.Println("outside:", count) // still 0
}

Il programma stampa inside: 42 e poi outside: 0. Il := dentro l'if ha dichiarato sia count sia err come nuove variabili nel blocco interno, perché nessuna delle due esisteva ancora lì. Compila senza problemi ed è una fonte classica di bug del tipo "il mio valore è sparito".

La soluzione è dichiarare prima err e assegnare con =:

var err error
count, err = strconv.Atoi(input)

go vet non segnala lo shadowing per default. Lo fa l'analizzatore separato shadow, e linter come golangci-lint possono attivarlo.

Nomi

• Usa il camelCase: maxRetries, userID. Non max_retries.
• Tieni gli acronimi tutti maiuscoli o tutti minuscoli: userID, httpClient, parseURL, non userId.
• Nomi brevi per scope brevi: i in un ciclo, r per un reader, err per un errore. Nomi più lunghi e descrittivi per le variabili a livello di pacchetto.
• Un nome con l'iniziale maiuscola a livello di pacchetto (var Timeout) viene esportato agli altri pacchetti. Vedi pacchetti e import.

Variabili a livello di pacchetto

Le variabili dichiarate fuori dalle funzioni vivono per tutta la durata del programma e vengono inizializzate prima che parta main, nell'ordine delle dipendenze. Sono comode per la configurazione e le cache, e sono condivise da tutte le goroutine. Se più di una goroutine ci scrive, proteggile con un mutex o usa sync/atomic, altrimenti hai una data race.

Preferisci le costanti per i valori che non cambiano mai. Una const non può essere modificata per sbaglio e non costa nulla durante l'esecuzione.