Kaip veikia uždarymai Go kalboje?

Question

Accepted Answer

**Uždarymą** yra funkcija, kuri nurodo kintamuosius iš jos aplinkinio mato, "uždarydama" juos — funkcija išlaiko prieigą prie tų kintamųjų net ir po to, kai išorinė funkcija grįžta. Go funkcijos yra pirmos klasės reikšmės, todėl uždarymai yra dažnas ir galingas įrankis.

## Pagrindinis uždarymą

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

Grąžinta funkcija išlaiko nuorodą į `count` net ir po to, kai `makeCounter` grįžta — todėl būsena išlieka per skambučius. Kiekvienas `makeCounter` skambučius sukuria naują, nepriklausomą `count`. Tai yra enkapsuliuota privati būsena.

## Uždarymai užfiksuoja kintamuosius pagal NUORODĄ (svarbus punktas)

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

## Klasikinis kilpos kintamojo pavojus

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

Tai yra žinomas klaida: uždarymai kilpoje visi užfiksavo *tą patį* kilpos kintamąjį. (Go 1.22 pataisė kilpos kintamojo aprėptį, bet suprasti šią problemą svarbu senesniame kode ir kitiems užfiksuotiems kintamiesiems.)

## Bendrieji uždarymo naudojimo atvejai

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

## Kodėl tai svarbu

Uždarymai yra galingas, dažnai naudojamas Go ypatybė, kurią įgalino pirmos klasės funkcijos — jie leidžia sukurti funkcijas, kurios turi privačią, nuolatinę būseną (skaitikliai, generatoriai, elgesys, konfigūruojamas per gamyklos funkcijas) ir yra būtini atgaliniam ryšiui, HTTP tvarkytuvams, atidėtam valymui, kuris nurodo vietinius kintamuosius, ir funkcinėms modeliams.

Supratimas, kad uždarymai užfiksuoja kintamuosius **pagal nuorodą** (matant esamąsias reikšmes, dalijantis būsena) — ne pagal reikšmę — yra svarbus tiek jų veiksmingam naudojimui (inkapsuliuota kintama būsena), tiek **klasikiniu kilpos kintamojo fiksavimo klaidos** išvengimui (visi uždarymai dalijasi vienu kintamuoju, garsusis painiavos šaltinis, pataisytas Go 1.22, tačiau vis dar aktualus senesniam kodui ir ne kilpos fiksavimui).

Uždarymai pasirodo visame idiomatiniame Go ir standartinės bibliotekos API, todėl jie yra svarbi praktinė žinias ir dažnai kylantis pokalbio tema.