closure ใน Go ทำงานอย่างไร?

Question

Accepted Answer

**closure** คือฟังก์ชันที่อ้างอิงตัวแปรจาก scope รอบ ๆ ตัวมัน โดย "ปิดล้อม (closing over)" ตัวแปรเหล่านั้น ฟังก์ชันยังคงเข้าถึงตัวแปรเหล่านั้นได้แม้ฟังก์ชันที่ห่อหุ้มจะ return ไปแล้ว ฟังก์ชันใน Go เป็นค่าระดับชั้นหนึ่ง ทำให้ closure เป็นเครื่องมือที่พบบ่อยและทรงพลัง

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

ฟังก์ชันที่ return ออกมายังคงเก็บ reference ไปยัง `count` แม้หลังจาก `makeCounter` return ไปแล้ว ดังนั้น state จึงคงอยู่ตลอดการเรียกใช้ การเรียก `makeCounter` แต่ละครั้งสร้าง `count` ใหม่ที่เป็นอิสระ นี่คือ state ส่วนตัวที่ถูกห่อหุ้มไว้

## closure จับตัวแปรแบบ REFERENCE (ประเด็นสำคัญ)

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

## ปัญหาคลาสสิกของตัวแปร 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.
```

นี่คือบั๊กที่โด่งดัง: closure ใน loop ทั้งหมดจับ *ตัวแปร loop ตัวเดียวกัน* (Go 1.22 แก้ scoping ของตัวแปร loop แล้ว แต่การเข้าใจปัญหานี้ยังสำคัญสำหรับโค้ดเก่าและตัวแปรอื่น ๆ ที่ถูกจับ)

## การใช้งาน 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
```

## ทำไมจึงสำคัญ

closure เป็นฟีเจอร์ของ Go ที่ทรงพลังและใช้บ่อย ซึ่งเกิดขึ้นได้จากฟังก์ชันที่เป็นค่าระดับชั้นหนึ่ง มันช่วยให้คุณสร้างฟังก์ชันที่พก state ส่วนตัวที่คงอยู่ (counter, generator, พฤติกรรมที่กำหนดค่าได้ผ่าน factory function) และจำเป็นสำหรับ callback, HTTP handler, การ cleanup แบบ deferred ที่อ้างอิงตัวแปร local และ pattern เชิงฟังก์ชัน

การเข้าใจว่า closure จับตัวแปรแบบ **reference** (เห็นค่าปัจจุบัน, แชร์ state) ไม่ใช่แบบ value เป็นเรื่องสำคัญทั้งสำหรับการใช้งานอย่างมีประสิทธิภาพ (state ที่เปลี่ยนแปลงได้และถูกห่อหุ้ม) และสำหรับการหลีกเลี่ยง **บั๊กการจับตัวแปร loop แบบคลาสสิก** (closure ทั้งหมดแชร์ตัวแปรเดียว ซึ่งเป็นแหล่งความสับสนที่ฉาวโฉ่ แม้จะถูกแก้ใน Go 1.22 แล้วแต่ยังเกี่ยวข้องกับโค้ดเก่าและการจับตัวแปรที่ไม่ใช่ใน loop)

closure ปรากฏอยู่ทั่วไปในโค้ด Go ที่ idiomatic และ API ของ standard library ทำให้มันเป็นความรู้เชิงปฏิบัติที่สำคัญและเป็นหัวข้อสัมภาษณ์ที่เกิดขึ้นซ้ำ ๆ