Defer, Panic และ Recover

JavaScript: try / finally / throw

TypeScript จัดการ cleanup และ error ด้วยสิ่งที่คุณคุ้นเคย: try/finally เพื่อรัน cleanup code ไม่ว่าจะเกิด error หรือไม่ และ throw/catch สำหรับการส่งต่อ error

Go มีของที่เทียบเคียงได้ครบทั้งสามตัว แต่หน้าตาต่างกันและมีพฤติกรรมที่ต่างกันในจุดสำคัญ

defer — cleanup ที่รันเสมอ

defer ตั้งเวลาเรียก function ให้รันตอนที่ function ที่ครอบอยู่ return ไม่ว่าจะ return ด้วยวิธีไหน (ปกติ, ผ่าน return, หรือหลัง panic) วิธีนี้มาแทน pattern cleanup แบบ try/finally ทั่วไป

// TypeScript — try/finally สำหรับ cleanup
async function readFile(path: string): Promise<string> {
  const fd = await openFile(path);
  try {
    return await fd.read();
  } finally {
    fd.close(); // รันเสมอ
  }
}

// Go — defer แทน try/finally
func readFile(path string) (string, error) {
    f, err := os.Open(path)
    if err != nil {
        return "", err
    }
    defer f.Close()    // จะรันเมื่อ readFile return

    data, err := io.ReadAll(f)
    if err != nil {
        return "", err
    }
    return string(data), nil
}

defer รันตาม LIFO

การเรียก defer หลายครั้งจะ stack ขึ้นและรัน last-in, first-out — ย้อนกลับจากลำดับที่ register ไว้ ซึ่งสะท้อนวิธีที่คุณมักต้องการ undo ขั้นตอน setup

// TypeScript — ต้องระบุลำดับใน finally อย่างชัดเจน
try {
  connectDB();
  startTransaction();
  doWork();
} finally {
  rollbackTransaction(); // ต้องระบุเอง
  disconnectDB();
}

func doWork() {
    connectDB()
    defer disconnectDB()     // register ที่ 1, รันที่ 2

    startTransaction()
    defer rollbackTransaction() // register ที่ 2, รันที่ 1

    // ถ้าขั้นตอนใด panic ทั้งสอง defer ก็ยังรัน (LIFO)
    processRows()
}

panic — เหมือน throw แต่สำหรับ error ที่กู้คืนไม่ได้

panic หยุด goroutine ปัจจุบัน unwind stack (รัน deferred function ทั้งหมดระหว่างทาง) แล้ว crash โปรแกรมถ้าไม่มีใครดักไว้ ใช้เฉพาะกับ programming error ที่ไม่ควรเกิดขึ้นในโค้ดที่ถูกต้อง ไม่ใช่สำหรับ error ที่คาดการณ์ได้ที่คุณต้องการส่งต่อให้ caller

// TypeScript — throw สำหรับ error ทุกประเภท
function divide(a: number, b: number): number {
  if (b === 0) throw new Error("division by zero");
  return a / b;
}
try {
  divide(10, 0);
} catch (e) {
  console.error(e.message);
}

// Go — return error สำหรับกรณีที่คาดการณ์ได้; panic สำหรับสถานะที่เป็นไปไม่ได้
func divide(a, b float64) float64 {
    if b == 0 {
        panic("หารด้วยศูนย์ — นี่คือ programming error")
    }
    return a / b
}

// สำหรับ error ที่คาดการณ์ได้ ให้ return (T, error) แทน:
func safeDivide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("ไม่สามารถหาร %v ด้วยศูนย์", a)
    }
    return a / b, nil
}

recover — ดัก panic

recover หยุด panic จากการแพร่กระจาย ต้องเรียกใน deferred function เท่านั้นจึงจะทำงาน นี่คือวิธีที่ Go library (และ HTTP server) ป้องกันไม่ให้ request เดียวที่มีปัญหา crash โปรแกรมทั้งหมด

// TypeScript — catch ครอบ throw
function safe(fn: () => void) {
  try {
    fn();
  } catch (err) {
    console.error("caught:", err);
  }
}

// Go — recover ใน defer
func safeRun(fn func()) (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic recovered: %v", r)
        }
    }()
    fn()
    return nil
}

func main() {
    err := safeRun(func() {
        panic("oh no!")
    })
    fmt.Println(err) // panic recovered: oh no!
}

ลองทำ

Open in Playground

package main

import "fmt"

func divide(a, b float64) (result float64, err error) {
  defer func() {
    if r := recover(); r != nil {
      err = fmt.Errorf("recovered from panic: %v", r)
    }
  }()
  if b == 0 {
    panic("division by zero")
  }
  return a / b, nil
}

func withCleanup() {
  fmt.Println("1. start")
  defer fmt.Println("3. cleanup (deferred)")
  fmt.Println("2. work")
}

func multiDefer() {
  for i := 1; i <= 3; i++ {
    defer fmt.Printf("deferred %d\n", i) // LIFO: 3, 2, 1
  }
}

func main() {
  withCleanup()
  fmt.Println("---")

  multiDefer()
  fmt.Println("---")

  r1, err := divide(10, 2)
  fmt.Printf("10/2 = %.1f err=%v\n", r1, err)

  r2, err := divide(5, 0)
  fmt.Printf("5/0  = %.1f err=%v\n", r2, err)
}

🟦 defer Argument ถูก Evaluate ทันที

เมื่อคุณเขียน defer f(x) Go จะ evaluate x ทันที (ที่ defer statement) ไม่ใช่ตอนที่ deferred call รันจริง มีแค่การเรียก function เองที่ถูกเลื่อน

x := 1
defer fmt.Println("deferred value:", x) // จับ x=1 ตอนนี้
x = 99
fmt.Println("current value:", x)        // print 99 ก่อน
// จากนั้น deferred print: deferred value: 1

เพื่อจับค่าตอนที่รันจริงแทน ให้ใช้ closure:

defer func() { fmt.Println("late value:", x) }() // จับ x by reference

🟦 panic vs error — ใช้เมื่อไหร่

นี่คือหนึ่งใน Go idiom ที่สำคัญที่สุด กฎเป็นเรื่องง่าย:

Return error สำหรับ failure mode ที่คาดการณ์ได้ — network timeout, file not found, invalid user input caller ต้องจัดการ
ใช้ panic เฉพาะสำหรับ invariant violation — index out of range, nil pointer dereference, หรือ logic bug ที่หมายความว่าโปรแกรมอยู่ในสถานะที่เป็นไปไม่ได้ อย่าใช้ panic สำหรับการจัดการ error ปกติ

Go standard library ใช้ convention นี้อย่างเคร่งครัด ตัวอย่างเช่น json.Unmarshal return error; json.Marshal panic เฉพาะเมื่อคุณส่ง type ที่ encode ไม่ได้ (programming mistake ไม่ใช่ user error)

// ดี — expected error, return มัน
func parseAge(s string) (int, error) {
    n, err := strconv.Atoi(s)
    if err != nil {
        return 0, fmt.Errorf("invalid age %q: %w", s, err)
    }
    return n, nil
}

// ดี — invariant violation, panic เหมาะสม
func mustPositive(n int) int {
    if n <= 0 {
        panic(fmt.Sprintf("mustPositive ถูกเรียกด้วย %d", n))
    }
    return n
}