Go मा closures कसरी काम गर्छन्?

Question

Accepted Answer

एक **closure** एक function हो जसले आफ्नो surrounding scope बाट variables लाई reference गर्छ, तिनीहरूलाई "close over" गर्छ — यो function enclosing function return भएपछी पनि ती variables मा access राखता। Go functions first-class values हुन्, जसले closures लाई सामान्य र शक्तिशाली tool बनाउँछ।

## एक आधारभूत 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
```

Returned function ले `count` को reference राखता `makeCounter` return भएपछी पनि — त्यसैले state calls भर persist गर्छ। `makeCounter` को प्रत्येक call ले एक fresh, independent `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 सबै एक ही *same* loop variable लाई capture गरेको हुन्छ। (Go 1.22 ले loop-variable scoping सुधार गरेको छ, तर पुरानो 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 feature हुन् जो first-class functions द्वारा सक्षम छन् — तिनीहरू तपाईंलाई functions सिर्जना गर्न दिन्छन् जो private, persistent state (counters, generators, configured behaviors via factory functions) लाई ढोक्छन् र callbacks, HTTP handlers, deferred cleanup को लागि आवश्यक हुन् जो local variables लाई reference गर्छ, र functional patterns को लागि।

यो बुझ्न कि closures variables लाई **by reference** (हालको मानहरू देख्ने, state साझा गर्ने) — value द्वारा होइन — महत्त्वपूर्ण छ दुबै तिनीहरूलाई प्रभावकारीसँग उपयोग गर्न (encapsulated mutable state) र **क्लासिक loop-variable capture bug** बाट बच्न (सबै closures एक variable साझा गर्ने, एक कुख्यात혼confusion को स्रोत, Go 1.22 मा सुधार भएको तर पुरानो code र non-loop captures को लागि अझै प्रासंगिक)।

Closures idiomatic Go र standard-library APIs भर देखिन्छन्, जसले तिनीहरूलाई महत्त्वपूर्ण व्यावहारिक ज्ञान र एक बारम्बार interview विषय बनाउँछ।