Bagaimana closures bekerja di Go?

Question

Accepted Answer

**Closure** adalah fungsi yang merujuk variabel dari lingkup sekitarnya, "menutup" variabel tersebut — fungsi mempertahankan akses ke variabel tersebut bahkan setelah fungsi yang membungkus mengembalikan nilai. Fungsi Go adalah nilai kelas pertama, membuat closures menjadi alat yang umum dan kuat.

## Closure dasar

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

Fungsi yang dikembalikan mempertahankan referensi ke `count` bahkan setelah `makeCounter` mengembalikan nilai — jadi statusnya tetap ada di seluruh pemanggilan. Setiap pemanggilan ke `makeCounter` membuat `count` baru yang independen. Ini adalah keadaan pribadi yang dienkapsulasi.

## Closures menangkap variabel DENGAN REFERENSI (poin kunci)

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

## Jebakan klasik variabel 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.
```

Ini adalah bug terkenal: closures dalam loop semuanya menangkap *variabel loop yang sama*. (Go 1.22 memperbaiki cakupan variabel loop, tetapi memahami masalah penting untuk kode lama dan variabel yang ditangkap lainnya.)

## Penggunaan umum 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
```

## Mengapa ini penting

Closures adalah fitur Go yang kuat dan sering digunakan, diaktifkan oleh fungsi kelas pertama — memungkinkan Anda membuat fungsi yang membawa keadaan pribadi yang persisten (penghitung, generator, perilaku yang dikonfigurasi melalui fungsi pabrik) dan penting untuk callback, penanganan HTTP, pembersihan tertunda yang merujuk variabel lokal, dan pola fungsional.

Memahami bahwa closures menangkap variabel **dengan referensi** (melihat nilai saat ini, berbagi keadaan) — bukan menurut nilai — sangat penting untuk menggunakannya secara efektif (keadaan yang dapat berubah yang dienkapsulasi) dan untuk menghindari **jebakan penangkapan variabel loop klasik** (semua closure berbagi satu variabel, sumber kebingungan yang terkenal, diperbaiki di Go 1.22 tetapi masih relevan untuk kode lama dan penangkapan non-loop).

Closures muncul di seluruh Go idiomatik dan API perpustakaan standar, menjadikannya pengetahuan praktis yang penting dan topik wawancara yang berulang.