Bagaimanakah closure berfungsi dalam Go?

Question

Accepted Answer

Sebuah **closure** adalah fungsi yang merujuk pemboleh ubah daripada skop sekitarnya, "menutup" mereka — fungsi mengekalkan akses ke pemboleh ubah tersebut bahkan selepas fungsi yang menutup ia kembali. Fungsi Go adalah nilai kelas pertama, menjadikan closure alat yang biasa dan berkuasa.

## Closure asas

```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 menyimpan rujukan kepada `count` walaupun selepas `makeCounter` kembali — jadi keadaan berterusan merentas panggilan. Setiap panggilan kepada `makeCounter` mencipta `count` yang segar dan bebas. Ini adalah keadaan peribadi yang dikapsulkan.

## Closure menangkap pemboleh ubah melalui RUJUKAN (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
```

## Masalah pemboleh ubah gelung klasik

```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 pepijat yang terkenal: closure dalam gelung semua menangkap pemboleh ubah gelung yang *sama*. (Go 1.22 memperbaiki skop pemboleh ubah gelung, tetapi memahami isu ini penting untuk kod lama dan pemboleh ubah yang ditangkap lainnya.)

## Kegunaan biasa 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
```

## Mengapa Ini Penting

Closure adalah ciri Go yang berkuasa dan sering digunakan yang diaktifkan oleh fungsi kelas pertama — ia memungkinkan anda membuat fungsi yang membawa keadaan peribadi yang kekal (pengira, penjana, kelakuan yang dikonfigurasi melalui fungsi pabrik) dan penting untuk panggilan balik, penangan HTTP, pembersihan tertunda yang merujuk pemboleh ubah tempatan, dan corak berfungsi.

Memahami bahawa closure menangkap pemboleh ubah **melalui rujukan** (melihat nilai semasa, berkongsi keadaan) — bukan mengikut nilai — adalah penting untuk menggunakannya dengan berkesan (keadaan boleh ubah yang dikapsulkan) dan untuk mengelakkan **pepijat tangkapan pemboleh ubah gelung klasik** (semua closure berkongsi satu pemboleh ubah, sumber kekeliruan yang terkenal, diperbaiki dalam Go 1.22 tetapi masih relevan untuk kod lama dan tangkapan bukan gelung).

Closure muncul di seluruh Go idiomatik dan API perpustakaan piawai, menjadikannya pengetahuan praktikal penting dan topik temu duga berulang.