Go میں closures کیسے کام کرتے ہیں؟

Question

Accepted Answer

ایک **closure** ایک function ہے جو اپنے ارد گرد کے scope کے variables کو reference کرتا ہے، انہیں "close over" کرتے ہوئے — یہ function enclosing function کے return کرنے کے بعد بھی ان variables تک رسائی برقرار رکھتا ہے۔ Go functions first-class values ہیں، جو closures کو ایک عام اور طاقتور ٹول بناتے ہیں۔

## ایک سادہ 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
```

واپس کیا گیا function `makeCounter` کے return کرنے کے بعد بھی `count` کو reference رکھتا ہے — اس لیے state calls کے دوران برقرار رہتا ہے۔ `makeCounter` کو ہر بار کال کرنا ایک نیا، آزاد `count` بناتا ہے۔ یہ encapsulated private state ہے۔

## Closures variables کو REFERENCE کے ذریعے capture کرتے ہیں (اہم نقطہ)

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

## کلاسیکی loop-variable gotcha

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

یہ ایک مشہور bug ہے: ایک loop میں closures سب نے *ایک جیسے* loop variable کو capture کیا۔ (Go 1.22 نے loop-variable scoping کو ٹھیک کیا، لیکن اس issue کو سمجھنا پرانے code اور دوسرے captured variables کے لیے اہم ہے۔)

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

## یہ کیوں اہم ہے

Closures ایک طاقتور، بار بار استعمال ہونے والی Go خصوصیت ہیں جو first-class functions کی وجہ سے ممکن ہیں — یہ آپ کو ایسے functions بنانے دیتے ہیں جو private، مستقل state (counters، generators، factory functions کے ذریعے configured behaviors) رکھتے ہیں اور callbacks، HTTP handlers، deferred cleanup جو local variables کو reference کرتے ہیں، اور functional patterns کے لیے ضروری ہیں۔

yہ سمجھنا کہ closures variables کو **reference کے ذریعے** (موجودہ values دیکھتے ہوئے، state share کرتے ہوئے) — value کے ذریعے نہیں — capture کرتے ہیں، انہیں موثر انداز میں استعمال کرنے (encapsulated mutable state) اور **classic loop-variable capture bug** سے بچنے (تمام closures ایک variable share کر رہے ہیں، الجھن کا ایک مشہور ذریعہ، Go 1.22 میں ٹھیک ہوا لیکن پرانے code اور non-loop captures کے لیے اب بھی متعلقہ) دونوں کے لیے بہت ضروری ہے۔

Closures پوری idiomatic Go اور standard-library APIs میں نمایاں ہیں، جو انہیں اہم عملی معلومات اور ایک بار بار آنے والا interview topic بناتے ہیں۔