Go లో closures ఎలా పని చేస్తాయి?

Question

Accepted Answer

A **closure** అనేది దాని చుట్టుపక్కల స్కోప్ నుండి వేరియబుల్‌లను సూచించే ఫంక్షన్, "closing over" — ఆ ఫంక్షన్ వాటిపై యాక్సెస్‌ను ఎన్‌క్లోజింగ్ ఫంక్షన్ రిటర్న్ చేసిన తర్వాత కూడా నిలుపుకుంటుంది. Go ఫంక్షన్‌లు first-class values, closures ను సాధారణ మరియు శక్తిశాली సాధనగా చేస్తాయి.

## A basic 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` కు రిఫరెన్స్‌ను నిలుపుకుంటుంది — కాబట్టి కాల్‌ల అంతటా స్థితి నిలుస్తుంది. `makeCounter` కు ప్రతి కాల్ తాజా, స్వతంత్ర `count` ను సృష్టిస్తుంది. ఇది encapsulated private state.

## Closures ఆ వేరియబుల్‌లను REFERENCE ద్వారా క్యాప్చర్ చేస్తాయి (key point)

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

## The classic 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.
```

ఇది ఒక ప్రసిద్ధ బగ్: ఒక లూప్‌లో closures అన్నీ *same* loop variable ను క్యాప్చర్ చేశాయి. (Go 1.22 loop-variable scoping ను సరిచేసింది, కానీ సమస్య అర్థం చేసుకోవడం పాతకోడ్ మరియు ఇతర క్యాప్చర్ చేయిన వేరియబుల్‌ల కోసం ముఖ్యమైనది.)

## Common uses of 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 ద్వారా ప్రేరితమైనది — అవి మీకు private, persistent state (counters, generators, configured behaviors via factory functions) ను నిర్వహించే ఫంక్షన్‌లను సృష్టించనివ్వాయి మరియు callbacks, HTTP handlers, deferred cleanup కోసం అవసరమైనవి ఇది local variables లను సూచిస్తుంది, మరియు functional patterns.

Closures వేరియబుల్‌లను **by reference** ఆ కారణం నుండి క్యాప్చర్ చేస్తాయని అర్థం చేసుకోవడం (current values చూడటం, sharing state) — by value కాదు — రెండింటికీ కీలకమైనది, వాటిని సమర్థవంతంగా ఉపయోగించడానికి (encapsulated mutable state) మరియు **classic loop-variable capture bug** ను నివారించడానికి (అన్ని closures ఒక వేరియబుల్‌ను పంచుకోవడం, గందరగోళం యొక్క ఖ్యాతి, Go 1.22 నుండి సరిచేసిన కానీ ఇప్పటికీ పాతకోడ్ మరియు non-loop captures కోసం సంబంధితమైనది).

Closures idiomatic Go మరియు standard-library APIs లలో కనిపిస్తాయి, వాటిని ముఖ్యమైన ప్రాక్టికల్ నాలెడ్జ మరియు తరచుగా సంభవించే ఇంటర్వ్యూ టాపిక్ చేస్తాయి.