Hogyan működnek a closures a Go-ban?

Question

Accepted Answer

A **closure** egy olyan függvény, amely hivatkozik a körülötte lévő hatókörből származó változókra, "bezárva" azokat — a függvény megtartja ezekhez a változókhoz való hozzáférést még akkor is, ha a bezáró függvény visszatér. A Go függvények első osztályú értékek, ami a closures-öket gyakori és erős eszközzé teszi.

## Alapvető 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
```

A visszaadott függvény megtartja a `count` hivatkozását még akkor is, amikor a `makeCounter` visszatér — így az állapot megmarad a hívások között. A `makeCounter` minden hívása egy új, független `count`-ot hoz létre. Ez egy beágyazott privát állapot.

## A closures HIVATKOZÁS SZERINT rögzítik a változókat (kulcsfontosságú pont)

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

## A klasszikus hurok-változó bukta

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

Ez egy híres hiba: a hurok closures-ei mindegyike az *ugyanaz* hurok-változót rögzítette. (A Go 1.22 kijavította a hurok-változó hatókörét, de a probléma megértése fontos a régebbi kódhoz és más rögzített változókhoz.)

## A closures gyakori felhasználása

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

## Miért fontos

A closures egy erős, gyakran használt Go-funkció, amelyet az első osztályú függvények tesznek lehetővé — lehetővé teszik olyan függvények létrehozását, amelyek magukkal viszik a privát, tartós állapotot (számlálók, generátorok, gyári függvények által konfigurált viselkedések) és elengedhetetlenek visszahívások, HTTP-kezelők, halasztott tisztítás, amely helyi változókra hivatkozik, és funkcionális minták számára.

Kulcsfontosságú megérteni, hogy a closures HIVATKOZÁS SZERINT **rögzítik a változókat** (megtekintik az aktuális értékeket, osztják az állapotot) — nem érték szerint — ez döntő fontosságú hatékony használatukhoz (beágyazott módosítható állapot) és a **klasszikus hurok-változó rögzítési hibatól** való elkerüléshez (az összes closure közösen használ egy változót, egy híres zavar forrása, a Go 1.22-ben kijavítva, de továbbra is releváns a régebbi kódhoz és nem hurok-rögzítésekhez).

A closures az idiomatikus Go-n és a standard könyvtári API-kon végig megjelennek, ami fontos gyakorlati ismeretek és egy ismétlődő interjú téma.