Hoe werken closures in Go?

Question

Accepted Answer

Een **closure** is een functie die variabelen uit de omliggende scope referentieert, deze "afsluitend" — de functie behoudt toegang tot die variabelen zelfs nadat de omvattende functie is geretourneerd. Go-functies zijn first-class values, wat closures een veelgebruikt en krachtig hulpmiddel maakt.

## Een basis closure

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

De geretourneerde functie behoudt een referentie naar `count` zelfs nadat `makeCounter` is geretourneerd — dus de state blijft behouden over aanroepen heen. Elke aanroep naar `makeCounter` creëert een verse, onafhankelijke `count`. Dit is ingekapseelde private state.

## Closures capteren variabelen op REFERENTIE (belangrijk punt)

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

## De klassieke loop-variabele valkuil

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

Dit is een beruchte bug: closures in een loop hebben allemaal dezelfde loop-variabele gecapteerd. (Go 1.22 heeft de loop-variabele scoping opgelost, maar het begrijpen van het probleem is belangrijk voor oudere code en andere gecaptureerde variabelen.)

## Veelgebruikte toepassingen van 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
```

## Waarom het belangrijk is

Closures zijn een krachtig, veelgebruikt Go-feature dat mogelijk wordt gemaakt door first-class functies — ze stellen je in staat functies te creëren die private, persistente state (tellers, generators, geconfigureerde gedragingen via factory functies) dragen en zijn essentieel voor callbacks, HTTP handlers, deferred cleanup die naar lokale variabelen verwijst, en functionele patronen.

Begrijpen dat closures variabelen **op referentie** capteren (huidige waarden zien, state delen) — niet op waarde — is cruciaal zowel voor het effectief gebruiken ervan (ingekapseelde mutable state) als voor het vermijden van de **klassieke loop-variabele capture bug** (alle closures delen één variabele, een beruchte bron van verwarring, sinds Go 1.22 opgelost maar nog steeds relevant voor oudere code en niet-loop captures).

Closures komen overal voor in idiomatische Go en standard-library API's, wat ze tot belangrijke praktische kennis en een terugkerend interviewonderwerp maakt.