Kako delujejo zaprtje (closures) v Go?

Question

Accepted Answer

**Zaprtje** je funkcija, ki se sklicuje na spremenljivke iz svoje okoliške sfere, »zaprte« okrog njih — funkcija ohrani dostop do teh spremenljivk tudi potem, ko se funkcija, ki jo vsebuje, vrne. Funkcije v Go-u so vrednosti prve vrste, kar naredi zaprtja skupna in zmogljiva orodja.

## Osnovno zaprtje

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

Vrnjena funkcija ohrani referenco na `count` tudi potem, ko se `makeCounter` vrne — zato stanje ostane ohranjena skozi klice. Vsak klic na `makeCounter` ustvari novo, neodvisno `count`. To je enkapsulirana zasebna stanja.

## Zaprtja zajamejo spremenljivke PO REFERENCI (ključna točka)

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

## Klasična past spremenljivke v zanki

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

To je znana napaka: zaprtja v zanki so vsa zajela *isto* spremenljivko zanke. (Go 1.22 je popravil obseg spremenljivke zanke, vendar razumevanje problema matters za starejšo kodo in druge zajete spremenljivke.)

## Pogoste uporabe zaprtij

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

## Zakaj je to pomembno

Zaprtja so zmogljivo, pogosto uporabljano značilnost Go-ja, omogočeno s funkcijami prve vrste — omogočajo vam ustvarjanje funkcij, ki nosijo zasebno, trajno stanja (števce, generatorje, konfigurirano obnašanje preko tovarnišnih funkcij) in so nujne za povratne klice, HTTP obdelovalce, odloženo čiščenje, ki se sklicuje na lokalne spremenljivke, in funkcionalne vzorce.

Razumevanje, da zaprtja zajamejo spremenljivke **po referenci** (vidijo trenutne vrednosti, delijo stanja) — ne po vrednosti — je ključno tako za učinkovito uporabo (enkapsulirana spremenljiva stanja) kot za izogibanje **klasični pasti zajema spremenljivke zanke** (vsa zaprtja delijo eno spremenljivko, znani vir zmede, odpravljeno v Go 1.22, vendar še vedno relevantno za starejšo kodo in zajeme brez zanke).

Zaprtja se pojavljajo skozi ves idiomatski Go in API-je standardne knjižnice, kar jih naredi važno praktično znanje in pogost topic za intervjuje.