Go-வில் closures எவ்வாறு வேலை செய்கின்றன?

Question

Accepted Answer

ஒரு **closure** என்பது அதன் சுற்றியுள்ள scope-இலிருந்து variables-ஐ குறிப்பிடும் ஒரு function ஆகும், அவற்றை "close over" செய்கிறது — enclosing function திரும்பிய பிறகும்கூட அந்த variables-க்கான அணுகலை function தக்கவைத்துக்கொள்கிறது. 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` திரும்பிய பிறகும்கூட `count`-க்கான ஒரு reference-ஐ வைத்திருக்கிறது — எனவே state ஆனது calls முழுவதும் நீடிக்கிறது. `makeCounter`-க்கான ஒவ்வொரு call-ம் ஒரு புதிய, சுயாதீனமான `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-ஐ சரிசெய்தது, ஆனால் பிரச்சினையைப் புரிந்துகொள்வது பழைய 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 ஆனவை first-class functions மூலம் சாத்தியமாக்கப்படும் ஒரு சக்திவாய்ந்த, அடிக்கடி பயன்படுத்தப்படும் Go அம்சமாகும் — அவை private, persistent state-ஐ (counters, generators, factory functions வழியாக configured behaviors) கொண்டிருக்கும் functions-ஐ உருவாக்க உங்களை அனுமதிக்கின்றன மற்றும் callbacks, HTTP handlers, local variables-ஐ குறிப்பிடும் deferred cleanup, மற்றும் functional patterns-க்கு அத்தியாவசியமானவை.

closures ஆனவை variables-ஐ **reference மூலம்** capture செய்கின்றன (தற்போதைய values-ஐ பார்த்தல், state-ஐ பகிர்தல்) — value மூலம் அல்ல — என்பதைப் புரிந்துகொள்வது, அவற்றை திறம்பட பயன்படுத்துவதற்கும் (encapsulated mutable state) மற்றும் **பாரம்பரிய loop-variable capture bug**-ஐ (ஒரு variable-ஐ பகிரும் அனைத்து closures, குழப்பத்தின் ஒரு பிரபலமான மூலம், Go 1.22-இல் சரிசெய்யப்பட்டது ஆனால் பழைய code மற்றும் non-loop captures-க்கு இன்னும் பொருத்தமானது) தவிர்ப்பதற்கும் முக்கியமானது.

Closures ஆனவை idiomatic Go மற்றும் standard-library APIs முழுவதும் தோன்றுகின்றன, இது அவற்றை முக்கியமான நடைமுறை அறிவாகவும் மீண்டும் வரும் interview தலைப்பாகவும் ஆக்குகிறது.