Closures ta aiki ta yaya a Go?

Question

Accepted Answer

**Closure** aiki ce da ta mayar da hankalin ga jiya daga jiyoyiyar ta, "rufe" kake — aiki ta ci gidaje hankalin waɗannan jiya har da jimre aiki na rufe ya dawo. Aikin Go na farko-aji daidai ce, wanda ya sa closures kayan sauuki wanda yake da iko.

## Closure na asali

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

Aiki da aka dawo yana da hankalin `count` har da `makeCounter` ya dawo — haka kuma tsarin yana dade a kiraye. Kowane kira zuwa `makeCounter` ya ka saba `count` sabon, mai zaman kansa. Wannan shine jiha jiya na siri wanda an rufe.

## Closures saka jiya NE HANKALIN (mahalaci muhimmi)

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

## Abin takaici na musamman na jiya-Loop

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

Wannan abin sakaci sanannun ce: closures a gidaje duka suka sako *daya* jiya-Loop. (Go 1.22 ya warware rubutu-jiya-Loop, amma fahimtar abin da ke ciki ya amfani da tsoffin rubutu da sauran jiya da aka sako.)

## Abubuwan damewa na 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
```

## Me ya sa mahimmanci

Closures aiki ne mai iko, wanda ake amfani da shi sau da yawa a Go, wanda aikace-aikacen farko-aji ya bayarwa — suna samun aiki waɗanda ke ɗauke da nasara, abin da ake ciyaki (ƙidaya, janareta, niyoyi waɗanda aka daidaita ta hanyar aiki na gida) kuma suna mahimmanci ga kiran baya, gudanar da HTTP, tsare matsayin da ya ɗauki jiya na gida, da nau'ikan aiki.

Ganin cewa closures saka jiya **NE HANKALIN** (ganin ƙimar jiya, raba tsarin) — ba ta dadawa ba — mahimmaci ne don amfani da su da sauƙi (ciyaki da aka rufe) kuma gare karɓawar **abin takaici na musamman na sako-jiya-Loop** (duka closures raba jiya, waje a san, a warware a Go 1.22 amma yana da mahimmanci ga tsoffin rubutu da rabe da ba Loop ba).

Closures yana bayyana a duk kofar Go da rahotanni-gidakiya ta standard, wanda ya sa su mahimmanci don sani mai aiki da bayan jiya na magana.