Wie funktionieren Closures in Go?

Question

Accepted Answer

A **closure** ist eine Funktion, die Variablen aus ihrem umgebenden Gültigkeitsbereich referenziert – die Funktion behält Zugriff auf diese Variablen, auch nachdem die umschließende Funktion zurückgekehrt ist. Go-Funktionen sind First-Class-Werte, was Closures zu einem häufigen und mächtigen Werkzeug macht.

## Eine einfache 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
```

Die zurückgegebene Funktion behält eine Referenz zu `count`, auch nachdem `makeCounter` zurückgekehrt ist – der Zustand bleibt also über mehrere Aufrufe hinweg erhalten. Jeder Aufruf von `makeCounter` erzeugt einen neuen, unabhängigen `count`. Das ist privater, gekapselt Zustand.

## Closures erfassen Variablen als REFERENZ (wichtig)

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

## Das klassische Loop-Variable-Problem

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

Das ist ein berühmter Bug: Closures in einer Schleife erfassen alle die *gleiche* Schleifenvariable. (Go 1.22 hat das Loop-Variable-Scoping behoben, aber das Verständnis des Problems ist wichtig für ältere Code-Versionen und andere erfasste Variablen.)

## Häufige Verwendungen von 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
```

## Warum es wichtig ist

Closures sind ein mächtiges, häufig verwendetes Go-Feature, das durch First-Class-Funktionen ermöglicht wird – sie lassen Sie Funktionen mit privatem, persistentem Zustand erstellen (Zähler, Generatoren, konfiguriertes Verhalten über Factory-Funktionen) und sind essenziell für Callbacks, HTTP-Handler, aufgeschobene Cleanup-Operationen, die lokale Variablen referenzieren, und funktionale Muster.

Zu verstehen, dass Closures Variablen **als Referenz** erfassen (aktuelle Werte sehen, Zustand teilen) – nicht nach Wert – ist entscheidend, sowohl um sie effektiv zu nutzen (privater, veränderlicher Zustand) als auch um das **klassische Loop-Variable-Capture-Problem** zu vermeiden (alle Closures teilen sich eine Variable, eine berüchtigte Quelle von Verwirrung, seit Go 1.22 behoben, aber immer noch relevant für ältere Code-Versionen und Non-Loop-Erfassungen).

Closures tauchen überall in idiomatischem Go und Standard-Library-APIs auf und machen sie zu wichtigem praktischem Wissen und einem wiederkehrenden Interview-Thema.