Go จัดการ error แบบเป็นค่า (values) อย่างไร?

Question

Accepted Answer

Go **ไม่มี exception** สำหรับ error ทั่วไป แต่ error จะเป็น **ค่า** ที่ถูกคืนจากฟังก์ชัน (โดยทั่วไปเป็นค่าคืนสุดท้าย) และผู้เรียก **ตรวจสอบอย่างชัดเจน** สิ่งนี้ทำให้การจัดการ error มองเห็นได้ ตั้งใจ และไม่สามารถละเลยอย่างเงียบ ๆ ได้ — เป็นปรัชญาที่นิยามตัวตนของ Go

## ชนิด error และรูปแบบหลัก

```go
// `error` is a built-in interface: anything with an Error() string method
type error interface {
    Error() string
}

// functions return (result, error) — error is nil on success
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")   // create an error
    }
    return a / b, nil    // nil = no error
}

// the ubiquitous calling pattern
result, err := divide(10, 0)
if err != nil {              // CHECK the error explicitly
    fmt.Println("error:", err)
    return
}
fmt.Println(result)
```

การตรวจสอบ `if err != nil { ... }` ปรากฏอยู่ตลอดเวลาใน Go — ทุกการดำเนินการที่อาจล้มเหลวจะตามด้วยการตรวจสอบ error อย่างชัดเจน ความยืดยาวนี้เป็นความตั้งใจ: error จะมองเห็นได้และถูกจัดการ ณ จุดที่เรียกเสมอ

## การสร้าง error

```go
errors.New("something failed")                       // simple error
fmt.Errorf("failed to process %s: %w", name, err)    // formatted, with WRAPPING (%w)
```

## การห่อ (wrapping) และตรวจสอบ error

```go
// %w WRAPS an underlying error, preserving the chain
if err != nil {
    return fmt.Errorf("reading config: %w", err)   // adds context, keeps original
}

// unwrap and inspect with errors.Is / errors.As
if errors.Is(err, os.ErrNotExist) { ... }          // check for a specific error
var pathErr *os.PathError
if errors.As(err, &pathErr) { ... }                 // extract a specific error type
```

การห่อ (`%w`) เพิ่ม context ขณะที่ error แพร่กระจายขึ้นไป ส่วน `errors.Is`/`errors.As` ช่วยให้คุณตรวจสอบหรือดึง error ต้นเหตุที่เฉพาะเจาะจงออกมาได้ — เป็นวิธีสมัยใหม่ในการจัดการ chain ของ error

## ชนิด error แบบกำหนดเอง

```go
type ValidationError struct {
    Field string
}
func (e *ValidationError) Error() string {           // implement the error interface
    return "invalid field: " + e.Field
}
return &ValidationError{Field: "email"}
```

## error เทียบกับ panic

```text
error (values) → EXPECTED, recoverable conditions (file missing, bad input) — the norm
panic          → UNEXPECTED, programmer errors / unrecoverable (nil deref, out of bounds)
→ Use errors for normal failure handling; reserve panic for truly exceptional cases.
```

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

แนวทาง error-as-value ของ Go เป็นหนึ่งในลักษณะเฉพาะที่นิยามตัวตนและถูกถกเถียงมากที่สุด แตกต่างจากภาษาที่ใช้ exception อย่างสิ้นเชิง

ด้วยการคืน error เป็นค่าที่ผู้เรียกต้องตรวจสอบอย่างชัดเจน (`if err != nil`) Go ทำให้การจัดการ error **มองเห็นได้ อยู่ในจุดที่เกิด (local) และไม่สามารถละเลยโดยบังเอิญ** — คุณเห็นชัดเจนว่าแต่ละ error ถูกจัดการที่ใด ซึ่งเพิ่มความน่าเชื่อถือโดยแลกกับความยืดยาว

การเข้าใจปรัชญานี้ รูปแบบ `(result, error)` การห่อ error (`%w`) ด้วย `errors.Is`/`errors.As` สำหรับการเพิ่ม context และตรวจสอบ chain ชนิด error แบบกำหนดเอง และความแตกต่างระหว่าง error (ปกติ กู้คืนได้) กับ panic (เหนือความคาดหมาย เป็นความผิดพลาดของโปรแกรมเมอร์) เป็นสิ่งจำเป็นอย่างยิ่ง — มันแทรกซึมอยู่ในทุกโปรแกรม Go และเป็นการเปลี่ยนกรอบความคิดหลักสำหรับนักพัฒนาที่มาจากภาษาที่ใช้ exception

และยังเป็นหนึ่งในหัวข้อสัมภาษณ์ Go ที่พบบ่อยที่สุดด้วย