Comment fonctionnent les closures en Go ?

Question

Accepted Answer

Une **closure** est une fonction qui référence des variables de sa portée environnante, « en se fermant dessus » — la fonction conserve l'accès à ces variables même après que la fonction englobante retourne. Les fonctions Go sont des valeurs de première classe, ce qui rend les closures un outil courant et puissant.

## Une closure basique

```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 fonction retournée garde une référence à `count` même après que `makeCounter` retourne — l'état persiste donc entre les appels. Chaque appel à `makeCounter` crée un nouveau `count` indépendant. C'est un état privé encapsulé.

## Les closures capturent les variables PAR RÉFÉRENCE (point clé)

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

## Le piège classique de la variable de boucle

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

C'est un bug célèbre : les closures dans une boucle ont toutes capturé la *même* variable de boucle. (Go 1.22 a corrigé la portée des variables de boucle, mais comprendre le problème importe pour l'ancien code et autres variables capturées.)

## Usages courants des closures

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

## Pourquoi c'est important

Les closures sont une fonctionnalité Go puissante et fréquemment utilisée, rendue possible par les fonctions de première classe — elles vous permettent de créer des fonctions qui portent un état privé et persistant (compteurs, générateurs, comportements configurés via des fonctions factory) et sont essentielles pour les callbacks, les gestionnaires HTTP, le nettoyage différé qui référence des variables locales, et les patterns fonctionnels.

Comprendre que les closures capturent les variables **par référence** (voyant les valeurs actuelles, partageant l'état) — et non par valeur — est crucial à la fois pour les utiliser efficacement (état mutable encapsulé) et pour éviter le **piège classique de capture de variable de boucle** (toutes les closures partageant une variable, une source notoire de confusion, corrigée depuis Go 1.22 mais toujours pertinente pour l'ancien code et les captures non-boucle).

Les closures apparaissent partout dans le Go idiomatique et les APIs de la bibliothèque standard, ce qui les rend importantes pour les connaissances pratiques et un sujet récurrent d'entretien.