როგორ მუშაობს closure Go-ში?

Question

Accepted Answer

**closure** არის ფუნქცია, რომელიც მიმართავს ცვლადებს მის გარშემო არსებული ფარგლებიდან, "დახურებს" მათ — ფუნქცია ინარჩუნებს წვდომას ამ ცვლადებზე თუნდაც მის გარსე ფუნქცია დასრულდეს. Go ფუნქციები არიან first-class values, რაც ხდის closure-ებს გავრცელებულ და ძლიერ ხელსაწყოს.

## ელემენტარული 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` დაბრუნდეს — ამიტომ მდგომარეობა უძღვება ყოველი გამოძახვის დროს. `makeCounter`-ის ყოველი გამოძახვა აკეთებს ახალ, დამოუკიდებელ `count`-ს. ეს არის ინკაპსულირებული კერძო მდგომარეობა.

## Closure ხელმისაწვდომელი ცვლადი მიხედვით 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-ცვლადის პრობლემა

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

ეს არის ცნობილი შეცდომა: loop-ში closure-ები ყველა დაჭერეს *იმავე* loop-ცვლადს. (Go 1.22 გამკრთალა loop-ცვლადის ფარგლები, მაგრამ პრობლემის გაგება აუცილებელია ძველი კოდისა და სხვა დაჭერილი ცვლადების შემთხვევაში.)

## Closure-ის გავრცელებული გამოყენება

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

## რატომ არის ეს მნიშვნელოვანი

Closure-ი არის ძლიერი, ხშირად გამოყენებული Go თვისება, რომელიც ხელმისაწვდომელია first-class ფუნქციებით — ისინი საშუალებას გაძლევთ შექმნათ ფუნქციები, რომლებიც ატარებენ კერძო, გამძლე მდგომარეობას (counters, generators, კონფიგურირებული ქცევა factory ფუნქციების მეშვეობით) და აუცილებელია callbacks, HTTP handlers, deferred cleanup, რომელიც მიმართავს ლოკალურ ცვლადებს, და ფუნქციონალური შაბლონებს.

რომ გასაგ იყოს, რომ closure-ი ხელმისაწვდომელი ცვლადი **მიხედვით რეფერენსი** (დღევანდელი მნიშვნელობების დანახვა, მდგომარეობის გაზიარება) — არა მნიშვნელობით — აუცილებელია როგორც მათი ეფექტიანად გამოყენებისთვის (ინკაპსულირებული ცვალებადი მდგომარეობა), ასევე **კლასიკური loop-ცვლადის დაჭერის შეცდომის** თავიდან აცილებისთვის (ყველა closure-ი ერთი ცვლადის გაზიარება, კცნობილი დაბნეულობის წყარო, რომელიც შესწორდა Go 1.22-ში, მაგრამ ჯერ კიდევ აქტუალური ძველი კოდისა და non-loop დაჭერის შემთხვევაში).

Closure-ი გამოჩნდება იდიომატიკური Go-სა და სტანდარტული ბიბლიოთეკის API-ებში, რაც მათ აქვს მნიშვნელოვანი პრაქტიკული ცოდნა და ხშირი საუბარი თემა.