¿Cómo funcionan los closures en Go?

Question

Accepted Answer

Un **closure** es una función que referencia variables del ámbito que la rodea, "cerrando sobre" ellas — la función retiene acceso a esas variables incluso después de que la función envolvente retorna. Las funciones de Go son valores de primera clase, lo que hace que los closures sean una herramienta común y poderosa.

## Un closure básico

```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 función retornada mantiene una referencia a `count` incluso después de que `makeCounter` retorna — así el estado persiste entre llamadas. Cada llamada a `makeCounter` crea un `count` fresco e independiente. Este es un estado privado encapsulado.

## Los closures capturan variables por REFERENCIA (punto clave)

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

## La trampa clásica de la variable de bucle

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

Este es un error famoso: los closures en un bucle capturaron todos la *misma* variable de bucle. (Go 1.22 arregló el alcance de la variable de bucle, pero entender el problema importa para código más antiguo y otras variables capturadas.)

## Usos comunes de 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
```

## Por qué es importante

Los closures son una característica de Go poderosa y frecuentemente usada habilitada por funciones de primera clase — te permiten crear funciones que llevan estado privado y persistente (contadores, generadores, comportamientos configurados a través de funciones factory) y son esenciales para callbacks, manejadores HTTP, limpieza diferida que referencia variables locales, y patrones funcionales.

Entender que los closures capturan variables **por referencia** (viendo valores actuales, compartiendo estado) — no por valor — es crucial tanto para usarlos efectivamente (estado mutable encapsulado) como para evitar la **trampa clásica de captura de variable de bucle** (todos los closures compartiendo una variable, una fuente notoria de confusión, arreglada en Go 1.22 pero aún relevante para código más antiguo y capturas no en bucles).

Los closures aparecen en todo el Go idiomático y en las APIs de la librería estándar, haciéndolos conocimiento práctico importante y un tema recurrente de entrevistas.