Cum funcționează închiderile (closures) în Go?

Question

Accepted Answer

O **închidere** (closure) este o funcție care referențiază variabile din scopul înconjurător, "închizând peste" acestea — funcția reține accesul la acele variabile chiar și după ce funcția care le conține se întoarce. Funcțiile Go sunt valori de primă clasă, ceea ce face ca închiderile să fie un instrument comun și puternic.

## O închidere de bază

```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
```

Funcția returnată păstrează o referință la `count` chiar și după ce `makeCounter` se întoarce — deci starea persists între apeluri. Fiecare apel la `makeCounter` creează un `count` nou și independent. Aceasta este stare privată încapsulată.

## Închiderile capturează variabile prin REFERINȚĂ (punct cheie)

```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
```

## Gotcha-ul clasic al variabilei din buclă

```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.
```

Aceasta este un bug celebru: închiderile dintr-o buclă au capturat toate aceeași variabilă de buclă. (Go 1.22 a remediat scopul variabilei de buclă, dar înțelegerea problemei este importantă pentru codul mai vechi și alte variabile capturate.)

## Utilizări comune ale închiderilor

```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
```

## De ce este important

Închiderile sunt o caracteristică Go puternică și frecvent utilizată, activată de funcțiile de primă clasă — vă permit să creați funcții care transportă stare privată și persistentă (contoare, generatoare, comportamente configurate prin funcții fabrica) și sunt esențiale pentru callback-uri, manevratori HTTP, curățare amânată care referențiază variabile locale și modele funcționale.

Înțelegerea că închiderile capturează variabile **prin referință** (văzând valorile curente, partajând stare) — nu după valoare — este crucială atât pentru a le folosi eficient (stare mutabilă încapsulată) cât și pentru a evita **gotcha-ul clasic al capturii variabilei din buclă** (toate închiderile partajând o variabilă, o sursă notorie de confuzie, remediată de atunci în Go 1.22 dar încă relevantă pentru codul mai vechi și capturi non-buclă).

Închiderile apar în întregul Go idiomativ și în API-urile bibliotecii standard, ceea ce le face cunoștințe practice importante și un subiect recurent de interviu.