Piye cara closure bisa makarya ing Go?

Question

Accepted Answer

Sebuah **closure** yaiku fungsi sing ngreferensial variabel saka scope sekitare, "tutup" sekebenere — fungsi tetep nduwe akses menyang variabel-variabel kasebut malah sawisé fungsi sing njaba bali. Fungsi Go minangka first-class values, dadi closure minangka tool sing umum lan 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 sing dibalekake tetep duwe referensi menyang `count` malah sawise `makeCounter` bali — dadi state tetep ana ing saben panggilan. Saben panggilan menyang `makeCounter` nggawe `count` sing anyar lan beda. Iki minangka state pribadi sing dikepung.

## Closure nangkep variabel kanthi REFERENCE (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
```

## Gotcha klasik saka 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.
```

Iki minangka bug sing misuwur: closure ing loop kabeh nangkep variabel loop sing *padha*. (Go 1.22 wis ngayomi scoping variabel loop, nanging ngerti masalahe penting kanggo kode lawas lan variabel sing ditangkep liyane.)

## Penggunaan closure sing umum

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

Closure yaiku fitur Go sing kuat lan asring digunakake sing diaktifake dening first-class functions — padha ngidini sampeyan nggawe fungsi sing ngandhut state pribadi sing tahan lama (counters, generators, perilaku sing dikonfigurasi via factory functions) lan penting kanggo callbacks, HTTP handlers, deferred cleanup sing ngreferensial variabel lokal, lan pola fungsional.

Mahami yen closure nangkep variabel **kanthi reference** (ndeleng nilai saiki, nuduh state) — ora kanthi nilai — penting kanggo nggunakake kanthi efektif (state mutable sing dikepung) lan kanggo ngindari **bug tangkep variabel loop klasik** (kabeh closure nuduh variabel siji, asal musibah sing luwih, wis ditonggo ing Go 1.22 nanging isih relevan kanggo kode lawas lan tangkep non-loop).

Closure katon ing Go idiomatic lan APIs perpustakaan standar, dadi pengetahuan praktis penting lan topik wawancara sing berulang.