Closures hufanyaje kazi katika Go?

Question

Accepted Answer

**Closure** ni function inayorejea variables kutoka kwa scope inayoizunguka, ikizifunga ("closing over") — function huhifadhi ufikiaji wa variables hizo hata baada ya function inayoizunguka kurudi. Functions za Go ni first-class values, zikifanya closures kuwa zana ya kawaida na yenye nguvu.

## Closure ya msingi

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

Function iliyorejeshwa huhifadhi rejeo la `count` hata baada ya `makeCounter` kurudi — kwa hivyo hali inadumu katika calls. Kila call ya `makeCounter` huunda `count` mpya, huru. Hii ni hali ya faragha iliyofungwa.

## Closures hukamata variables kwa REJEO (jambo muhimu)

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

## Tatizo la kawaida la loop-variable

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

Hili ni bug maarufu: closures katika loop zote zilikamata loop variable *moja* ile ile. (Go 1.22 ilirekebisha loop-variable scoping, lakini kuelewa suala hili ni muhimu kwa code ya zamani na variables nyingine zilizokamatwa.)

## Matumizi ya kawaida ya 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
```

## Kwa nini ni muhimu

Closures ni kipengele chenye nguvu, kinachotumika mara kwa mara cha Go kinachowezeshwa na first-class functions — zinakuwezesha kuunda functions zinazobeba hali ya faragha, inayodumu (counters, generators, tabia zilizosanidiwa kupitia factory functions) na ni muhimu kwa callbacks, HTTP handlers, deferred cleanup inayorejea variables za ndani, na mifumo ya functional.

Kuelewa kwamba closures hukamata variables **kwa rejeo** (zikiona maadili ya sasa, zikishiriki hali) — si kwa thamani — ni muhimu kwa kuzitumia kwa ufanisi (hali inayoweza kubadilika iliyofungwa) na kwa kuepuka **bug ya kawaida ya loop-variable capture** (closures zote zikishiriki variable moja, chanzo maarufu cha kuchanganyikiwa, ingawa kilirekebishwa katika Go 1.22 lakini bado kinafaa kwa code ya zamani na captures zisizo za loop).

Closures huonekana katika Go ya kiidiomatiki yote na APIs za standard-library, zikifanya kuwa maarifa muhimu ya vitendo na mada ya mara kwa mara ya mahojiano.