Si funksionojnë mbylljet në Go?

Question

Accepted Answer

Një **mbyllje** është një funksion që referon variabla nga shkrimi i tij përreth, "duke u mbyllur mbi" ato — funksioni ruan qasjen në ato variabla edhe pasi funksioni përrethues kthehet. Funksionet Go janë vlera të rendit të parë, duke e bërë mbylljen një mjet të zakonshëm dhe të fuqishëm.

## Një mbyllje themelore

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

Funksioni i kthyer ruan një referencë në `count` edhe pasi `makeCounter` kthehet — kështu gjendja përvetueshme në të gjitha thirrjet. Çdo thirrje në `makeCounter` krijon një `count` të ri dhe të pavarur. Kjo është gjendje private e mbyllur në paketë.

## Mbylljet kapin variabla sipas REFERENCËS (pika kyçe)

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

## Problemi i njohur i variablës lak

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

Kjo është një gabim i famshëm: mbylljeta në një lak të gjitha kapin *të njëjtën* variabël lak. (Go 1.22 rregulloi shkrimin e variablës lak, por kuptimi i problemit ka rëndësi për kodin më të vjetër dhe variablat e tjera të kapur.)

## Përdorimet e zakonshme të mbylljeve

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

## Pse ka rëndësi

Mbylljeta janë një veçori e fuqishme, shpesh e përdorur në Go e mundësuar nga funksionet e rendit të parë — ato ju lejojnë të krijoni funksione që bartin gjendje private, përvetueshme (numërues, gjeneratorë, sjelljë e konfiguruar përmes funksioneve fabrike) dhe janë thelbësore për thirrje përgjigjejeash, përpunuesit HTTP, pastrimi i shtyer që referon variablat lokale, dhe modelet funksionale.

Kuptimi se mbylljeta kapin variabla **sipas referencës** (duke parë vlerat aktuale, duke ndarë gjendje) — jo sipas vlere — është vendimtar si për përdorimin e tyre efektiv (gjendje private e ndryshme) ashtu edhe për shmangien e **problemit klasik të kapjes së variablës lak** (të gjitha mbylljeta që ndajnë një variabël, një burim i njohur i hutimit, që atëherë është rregulluar në Go 1.22 por ende i përshtatshëm për kodin më të vjetër dhe kapjet jo-lak).

Mbylljeta shfaqen në të gjithë Go idiomatik dhe APIs e bibliotekës standarde, duke i bërë ato njohuri praktike të rëndësishme dhe një temë e përsëritur në intervista.