Go-তে closures কীভাবে কাজ করে?

Question

Accepted Answer

একটি **closure** হল এমন একটি ফাংশন যা তার চারপাশের স্কোপ থেকে ভেরিয়েবল রেফারেন্স করে, সেগুলোকে "বন্ধ করে"। ফাংশনটি এনক্লোজিং ফাংশন রিটার্ন করার পরেও সেই ভেরিয়েবলগুলোতে অ্যাক্সেস বজায় রাখে। Go ফাংশনগুলো 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
```

রিটার্ন করা ফাংশনটি `makeCounter` রিটার্ন করার পরেও `count` এর একটি রেফারেন্স রাখে — তাই স্টেট কল জুড়ে persists করে। `makeCounter` এর প্রতিটি কল একটি তাজা, স্বাধীন `count` তৈরি করে। এটি এনক্যাপসুলেটেড প্রাইভেট স্টেট।

## Closures ভেরিয়েবল REFERENCE দ্বারা ক্যাপচার করে (মূল বিষয়)

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

## ক্লাসিক লুপ-ভেরিয়েবল সমস্যা

```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: লুপে closures সবাই একই লুপ ভেরিয়েবল ক্যাপচার করেছে। (Go 1.22 লুপ-ভেরিয়েবল স্কোপিং ঠিক করেছে, কিন্তু সমস্যাটি বোঝা পুরানো কোড এবং অন্যান্য ক্যাপচার করা ভেরিয়েবলের জন্য গুরুত্বপূর্ণ।)

## 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 ফাংশন দ্বারা সক্ষম — তারা আপনাকে এমন ফাংশন তৈরি করতে দেয় যা প্রাইভেট, persistent স্টেট (counters, generators, configured behaviors via factory functions) বহন করে এবং callbacks, HTTP handlers, deferred cleanup যা লোকাল ভেরিয়েবল রেফারেন্স করে, এবং functional patterns এর জন্য অপরিহার্য।

যে closures ভেরিয়েবল **by reference** ক্যাপচার করে (বর্তমান মান দেখে, স্টেট শেয়ার করে) — মান দ্বারা নয় — এটি বোঝা সেগুলো কার্যকরভাবে ব্যবহার করার জন্য (encapsulated mutable state) এবং **classic loop-variable capture bug** এড়ানোর জন্য উভয়ের জন্যই গুরুত্বপূর্ণ (সব closures একটি ভেরিয়েবল শেয়ার করে, বিভ্রান্তির একটি কুখ্যাত উৎস, Go 1.22 এ সংশোধিত কিন্তু পুরানো কোড এবং non-loop captures এর জন্য এখনও প্রাসঙ্গিক)।

Closures idiomatic Go এবং standard-library APIs জুড়ে প্রদর্শিত হয়, যা তাদের গুরুত্বপূর্ণ ব্যবহারিক জ্ঞান এবং একটি পুনরাবৃত্ত ইন্টারভিউ বিষয় করে তোলে।