Come funzionano le closure in Go?

Question

Accepted Answer

Una **closure** è una funzione che referenzia variabili dal suo scope circostante, "chiudendosi intorno ad esse" — la funzione mantiene l'accesso a quelle variabili anche dopo che la funzione esterna ritorna. Le funzioni Go sono first-class values, rendendo le closure uno strumento comune e potente.

## Una closure di base

```go
func makeCounter() func() int {
    count := 0                  // a local variable
    return func() int {          // this inner function CLOSES OVER count
        count++                  // it can read AND modify count
        return count
    }
}

counter := makeCounter()
fmt.Println(counter())   // 1
fmt.Println(counter())   // 2 — count PERSISTS between calls (state is retained)

other := makeCounter()    // a NEW, independent closure with its own count
fmt.Println(other())     // 1 — separate state
```

La funzione ritornata mantiene un riferimento a `count` anche dopo che `makeCounter` ritorna — quindi lo stato persiste attraverso le chiamate. Ogni chiamata a `makeCounter` crea un `count` fresco e indipendente. Questo è uno stato privato incapsulato.

## Le closure catturano variabili per REFERENCE (punto chiave)

```go
// closures capture the variable itself, not a snapshot of its value
x := 10
f := func() int { return x }
x = 20
fmt.Println(f())   // 20 — sees the CURRENT value of x, not 10
```

## Il classico gotcha della variabile di loop

```go
// ⚠️ in Go versions BEFORE 1.22:
funcs := []func(){}
for i := 0; i < 3; i++ {
    funcs = append(funcs, func() { fmt.Println(i) })  // all close over the SAME i
}
for _, f := range funcs { f() }   // prints 3, 3, 3 (not 0, 1, 2)! — all share i

// the classic fix (pre-1.22): make a per-iteration copy
for i := 0; i < 3; i++ {
    i := i                          // shadow with a new variable each iteration
    funcs = append(funcs, func() { fmt.Println(i) })
}
// Note: Go 1.22+ changed loop semantics so each iteration gets a NEW variable — this bug is fixed.
```

Questo è un bug famoso: le closure in un loop hanno tutte catturato la *stessa* variabile di loop. (Go 1.22 ha risolto lo scoping della variabile di loop, ma comprendere il problema importa per il codice precedente e altre variabili catturate.)

## Usi comuni delle closure

```go
// 1. as callbacks / handlers
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { ... })

// 2. deferred functions capturing local state
defer func() { fmt.Println("cleanup with", localVar) }()

// 3. function factories (configured behavior)
func multiplier(factor int) func(int) int {
    return func(n int) int { return n * factor }
}
double := multiplier(2)   // double(5) → 10
```

## Perché è importante

Le closure sono una funzionalità Go potente e frequentemente usata resa possibile dalle funzioni first-class — ti permettono di creare funzioni che portano stato privato e persistente (contatori, generatori, comportamenti configurati tramite factory functions) e sono essenziali per callback, HTTP handlers, defer per pulizia che referenzia variabili locali, e pattern funzionali.

Comprendere che le closure catturano variabili **per reference** (vedendo valori attuali, condividendo stato) — non per valore — è cruciale sia per usarle efficacemente (stato mutabile incapsulato) sia per evitare il **classico bug di cattura della variabile di loop** (tutte le closure che condividono una variabile, una fonte notoria di confusione, risolta in Go 1.22 ma comunque rilevante per codice precedente e catture non-loop).

Le closure appaiono in tutto il Go idiomatico e nelle API della standard library, rendendole conoscenza pratica importante e un argomento ricorrente nei colloqui.