Go ਵਿੱਚ closures ਕਿਵੇਂ ਕਾਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

**closure** ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਆਪਣੇ ਆਸ-ਪਾਸ ਦੇ ਸਕੋਪ ਤੋਂ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ, "ਬੰਦ ਕਰਦਾ ਹੈ" — ਫੰਕਸ਼ਨ ਉਹਨਾਂ ਵੇਰੀਏਬਲਾਂ ਤੱਕ ਪਹੁੰਚ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ ਭਾਵੇਂ enclosing ਫੰਕਸ਼ਨ return ਹੋ ਜਾਵੇ। Go ਫੰਕਸ਼ਨਾਂ ਫਰਸਟ-ਕਲਾਸ ਮੁੱਲ ਹਨ, ਜੋ 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
```

ਵਾਪਸ ਕੀਤਾ ਗਿਆ ਫੰਕਸ਼ਨ `count` ਦਾ ਹਵਾਲਾ ਰੱਖਦਾ ਹੈ ਭਾਵੇਂ `makeCounter` return ਹੋ ਜਾਵੇ — ਇਸ ਲਈ ਸਥਿਤਿ calls ਵਿੱਚ ਬਰਕਰਾਰ ਰਹਿੰਦੀ ਹੈ। `makeCounter` ਦੇ ਹਰੇਕ call ਨੂੰ ਇੱਕ ਤਾਜ਼ਾ, ਸੁਤੰਤਰ `count` ਮਿਲਦਾ ਹੈ। ਇਹ encapsulated private ਸਥਿਤਿ ਹੈ।

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

## ਕਲਾਸਿਕ 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.
```

ਇਹ ਇੱਕ ਮਸ਼ਹੂਰ bug ਹੈ: ਇੱਕ loop ਵਿੱਚ closures ਸਭ *ਉਹੀ* loop variable ਨੂੰ ਕੈਪਚਰ ਕਰਦੇ ਹਨ। (Go 1.22 ਨੇ loop-variable scoping ਨੂੰ ਠੀਕ ਕੀਤਾ, ਪਰ ਬਜ਼ੁਰਗ ਕੋਡ ਅਤੇ ਦੂਸਰੀਆਂ ਕੈਪਚਰ ਕੀਤੀਆਂ ਵੇਰੀਏਬਲਾਂ ਲਈ ਸਮਸਿਆ ਨੂੰ ਸਮਝਣਾ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ।)

## 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 ਫੰਕਸ਼ਨਾਂ ਦੁਆਰਾ ਸਮਰਥ ਹੈ — ਉਹ ਤੁਹਾਨੂੰ ਅਜਿਹੇ ਫੰਕਸ਼ਨ ਬਣਾਉਣ ਦਿੰਦਾ ਹੈ ਜੋ private, persistent state (counters, generators, factory ਫੰਕਸ਼ਨਾਂ ਦੁਆਰਾ ਸੰਰਚਿਤ ਵਿਵਹਾਰ) ਨੂੰ ਲਿਜਾਂਦੇ ਹਨ ਅਤੇ callbacks, HTTP handlers, deferred cleanup ਜੋ local ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਹਵਾਲਾ ਦਿੰਦੇ ਹਨ, ਅਤੇ functional patterns ਲਈ ਜ਼ਰੂਰੀ ਹਨ।
	rhanਧਿਆਨ ਰਵੈਣਾ ਕਿ closures ਵੇਰੀਏਬਲਾਂ ਨੂੰ **by reference** ਕੈਪਚਰ ਕਰਦੇ ਹਨ (ਮੌਜੂਦਾ ਮੁੱਲਾਂ ਨੂੰ ਦੇਖਦੇ ਹੋਏ, state ਸਾਂਝਾ ਕਰਦੇ ਹੋਏ) — by value ਦੁਆਰਾ ਨਹੀਂ — ਸ਼ਕਤੀਸ਼ਾਲੀ ਵਰਤੋਂ ਲਈ ਅਤੇ **classic loop-variable capture bug** ਨੂੰ ਰੋਕਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ (ਸਾਰੇ closures ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਸਾਂਝਾ ਕਰਦੇ ਹਨ, ਉਲਝਣ ਦਾ ਇੱਕ ਦੁਖਦ ਸਰੋਤ, ਜੋ Go 1.22 ਵਿੱਚ ਠੀਕ ਹੋ ਗਿਆ ਪਰ ਬਜ਼ੁਰਗ ਕੋਡ ਅਤੇ non-loop captures ਲਈ ਅਜੇ ਵੀ ਪ੍ਰਾਸੰਗਿਕ ਹੈ)।

Closures idiomatic Go ਅਤੇ standard-library APIs ਵਿੱਚ ਹਰ ਜਗਾ ਮਿਲਦੇ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਵਿਵਹਾਰਕ ਗਿਆਨ ਅਤੇ ਇੱਕ ਵਾਰ-ਵਾਰ ਆਉਣ ਵਾਲਾ interview ਵਿਸ਼ਾ ਬਣਾਉਂਦਾ ਹੈ।