Como os closures funcionam em Go?

Question

Accepted Answer

Um **closure** é uma função que referencia variáveis do seu escopo envolvente, "fechando sobre" elas — a função mantém acesso àquelas variáveis mesmo após a função envolvente retornar. Funções em Go são valores de primeira classe, tornando closures uma ferramenta comum e poderosa.

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

A função retornada mantém uma referência a `count` mesmo após `makeCounter` retornar — então o estado persiste entre chamadas. Cada chamada a `makeCounter` cria um `count` fresco e independente. Este é um estado privado encapsulado.

## Closures capturam variáveis por REFERÊNCIA (ponto-chave)

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

## O clássico problema de variável de 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.
```

Este é um bug famoso: closures em um loop todos capturaram a *mesma* variável de loop. (Go 1.22 corrigiu o escopo da variável de loop, mas entender o problema importa para código antigo e outras variáveis capturadas.)

## Usos comuns 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 que isso importa

Closures são um recurso poderoso e frequentemente usado em Go, habilitado por funções de primeira classe — eles permitem que você crie funções que carregam estado privado e persistente (contadores, geradores, comportamentos configurados via funções factory) e são essenciais para callbacks, handlers HTTP, limpeza adiada que referencia variáveis locais e padrões funcionais.

Entender que closures capturam variáveis **por referência** (vendo valores atuais, compartilhando estado) — não por valor — é crucial tanto para usá-los efetivamente (estado mutável encapsulado) quanto para evitar o **clássico bug de captura de variável de loop** (todos os closures compartilhando uma variável, uma fonte notória de confusão, corrigida em Go 1.22 mas ainda relevante para código antigo e capturas fora de loops).

Closures aparecem em todo Go idiomático e APIs da biblioteca padrão, tornando-os conhecimento prático importante e um tópico recorrente em entrevistas.