defer, panic และ recover ทำอะไร?

Question

Accepted Answer

คีย์เวิร์ดทั้งสามนี้จัดการการทำงานแบบเลื่อนเวลา (deferred execution) และสถานการณ์เหนือความคาดหมาย **`defer`** กำหนดเวลาให้ทำการ cleanup, **`panic`** กระตุ้นการ crash ขณะ runtime (สำหรับกรณีที่เหนือความคาดหมายจริง ๆ) และ **`recover`** สามารถดักจับ panic เพื่อป้องกันไม่ให้โปรแกรม crash

## defer — กำหนดให้เรียกเมื่อฟังก์ชันคืนค่า

```go
func readFile() error {
    f, err := os.Open("file.txt")
    if err != nil { return err }
    defer f.Close()        // GUARANTEED to run when readFile returns (any path)

// ... use f, with multiple return points ...
    return nil             // f.Close() runs here automatically
}
```

`defer` กำหนดให้เรียกฟังก์ชันเมื่อฟังก์ชันที่ครอบอยู่คืนค่า — ไม่ว่ามันจะคืนค่าด้วยวิธีใด (return ปกติ, error หรือ panic) มันเป็นวิธีที่เป็นสำนวนในการรับประกันการ cleanup: ปิดไฟล์ ปลดล็อก mutex ปิด connection — วางไว้ติดกับการ acquire เพื่อที่คุณจะลืมไม่ได้

## defer หลายตัวทำงานแบบ LIFO

```go
defer fmt.Println("1")
defer fmt.Println("2")
defer fmt.Println("3")
// prints: 3, 2, 1 — last deferred, first executed (stack order)
```

## panic — สำหรับสถานการณ์เหนือความคาดหมายที่กู้คืนไม่ได้จริง ๆ

```go
func mustPositive(n int) {
    if n < 0 {
        panic("negative not allowed")   // stops normal execution, unwinds the stack
    }
}
// panic runs deferred functions as it unwinds, then crashes the program (with a stack trace)
```

`panic` หยุดการทำงานปกติและคลาย (unwind) call stack (โดยรันฟังก์ชันที่ถูก defer ระหว่างทาง) และสุดท้ายทำให้โปรแกรม crash มันมีไว้สำหรับ **ความผิดพลาดของโปรแกรมเมอร์ / สภาวะที่กู้คืนไม่ได้** (out-of-bounds, nil dereference, สภาวะที่เป็นไปไม่ได้) — ไม่ใช่สำหรับ error ทั่วไป (พวกนั้นใช้ค่า `error` ที่คืนกลับมา)

## recover — ดักจับ panic (ทำงานได้ภายในฟังก์ชันที่ถูก defer เท่านั้น)

```go
func safeProcess() {
    defer func() {
        if r := recover(); r != nil {        // recover() returns the panic value
            fmt.Println("recovered from:", r)  // handle it; program continues
        }
    }()
    panic("something broke")    // this panic is caught by the recover above
}
// safeProcess returns normally instead of crashing
```

`recover` ดึงการควบคุม goroutine ที่กำลัง panic กลับคืนมา — แต่ **ทำงานได้ภายในฟังก์ชันที่ถูก defer เท่านั้น** มันถูกใช้อย่างประหยัด เช่น เพื่อหยุดไม่ให้ตัวจัดการ request หนึ่งทำให้เซิร์ฟเวอร์ทั้งตัว crash

## หลักการสำคัญ: อย่าใช้ panic/recover สำหรับ error ทั่วไป

```text
Normal/expected failures (file missing, bad input, validation) → return an error value
panic/recover → reserve for TRULY exceptional cases (bugs, unrecoverable states)
  and boundaries (e.g. a server recovering so one bad request doesn't kill the process)
```

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

`defer` เป็นคุณสมบัติที่จำเป็นและเป็นสำนวนของ Go สำหรับ **การ cleanup ที่รับประกันได้** — วางการปล่อยทรัพยากรไว้ติดกับการ acquire และมั่นใจว่ามันจะรันในทุกเส้นทางการคืนค่า (รวมถึงตอน panic) ซึ่งป้องกันการรั่วไหลของไฟล์ lock และ connection ได้น่าเชื่อถือกว่าการ cleanup ด้วยมือมาก

การเข้าใจการเรียงลำดับแบบ LIFO ก็สำคัญเช่นกัน ส่วน `panic`/`recover` ให้กลไกคล้าย exception แต่ **หลักการสำคัญ** คือ Go สงวนมันไว้สำหรับสถานการณ์ที่เหนือความคาดหมายและกู้คืนไม่ได้จริง ๆ — error ทั่วไปควรถูกคืนเป็นค่าและตรวจสอบเสมอ

การใช้ panic/recover ผิดวัตถุประสงค์เป็นการจัดการ exception ทั่วไปเป็นสิ่งที่ไม่เป็นสำนวนและเป็นข้อผิดพลาดที่พบบ่อยสำหรับนักพัฒนาที่มาจากภาษาที่ใช้ exception

การรู้ว่าเมื่อใดควรใช้ `defer` (เสมอ สำหรับการ cleanup), การคืนค่า `error` (ความล้มเหลวทั่วไป) และ `panic`/`recover` (น้อยครั้ง เหนือความคาดหมาย หรือที่ขอบเขต) เป็นพื้นฐานของการเขียน Go ที่ถูกต้องและเป็นสำนวน และเป็นหัวข้อสัมภาษณ์ที่พบบ่อย