Closure'lar Go'da nasıl çalışır?

Question

Accepted Answer

**Closure**, çevresindeki kapsamdan değişkenleri referans alan bir fonksiyondur — fonksiyon, çevreleyen fonksiyon geri döndüğünden sonra bile bu değişkenlere erişimi korur. Go fonksiyonları first-class değerdir, bu da closure'ları yaygın ve güçlü bir araç haline getirir.

## Basit bir 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
```

Döndürülen fonksiyon, `makeCounter` geri döndükten sonra bile `count`'a bir referans tutar — bu nedenle durum çağrılar arasında kalıcı kalır. `makeCounter`'a yapılan her çağrı yeni, bağımsız bir `count` oluşturur. Bu, kapsüllenmiş özel durumdur.

## Closure'lar değişkenleri REFERANS ile yakalar (önemli nokta)

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

## Klasik döngü-değişkeni tuzağı

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

Bu ünlü bir hatadır: bir döngüdeki closure'lar aynı döngü değişkenini yakalamıştır. (Go 1.22 döngü-değişkeni kapsamını düzeltti, ancak sorunu anlamak eski kod ve diğer yakalanan değişkenler için önemlidir.)

## Closure'ların yaygın kullanımları

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

## Neden önemli

Closure'lar, first-class fonksiyonlar tarafından etkinleştirilen güçlü, sık kullanılan bir Go özelliğidir — özel, kalıcı durumu olan fonksiyonlar oluşturmanızı sağlarlar (sayaçlar, üreticiler, factory fonksiyonları aracılığıyla yapılandırılmış davranışlar) ve geri çağrılar, HTTP işleyicileri, yerel değişkenleri referans alan ertelenmiş temizlik ve fonksiyonel desenler için gereklidir.

Closure'ların değişkenleri **referans ile** (güncel değerleri görerek, durumu paylaşarak) — değer ile değil — yakalama olgusunu anlamak hem bunları etkili bir şekilde kullanmak (kapsüllenmiş değişebilir durum) hem de **klasik döngü-değişkeni yakalama hatası**ndan kaçınmak (tüm closure'lar bir değişkeni paylaşır, kafa karışıklığının ünlü bir kaynağı, Go 1.22'de düzeltildi ancak eski kod ve döngü dışı yakalamalar için hala geçerli) için çok önemlidir.

Closure'lar idiyomatik Go'da ve standart kütüphane API'lerinde yaygın olarak görünür, bu da onları önemli pratik bilgi ve yinelenen bir mülakat konusu haline getirir.