Error Architecture: error คือข้อมูล ไม่ใช่ข้อความ

1 · error เป็นแค่ interface ที่มี method เดียว

// นิยามจริงใน Go — built-in ไม่ต้อง import อะไร
type error interface {
    Error() string
}

แค่นั้นจริง ๆ อะไรก็ตามที่มี method Error() string คือ error ได้ทันที — ตรงตาม duck typing จาก บทเรียน 10 แปลว่าคุณสร้าง error ที่พก field อะไรก็ได้ ติดไปด้วย (field = ช่องข้อมูลใน struct เหมือนช่องกรอกในแบบฟอร์ม)

type ValidationError struct {
    Field   string
    Message string
}

func (e ValidationError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Message)
}

func ValidateAge(age int) error {
    if age < 0 {
        return ValidationError{
            Field:   "age",
            Message: "must not be negative",
        }
    }
    return nil
}

ตอนนี้ผู้เรียกได้มากกว่าข้อความ — ได้ Field ไปใช้ highlight ช่องกรอกที่ผิดในหน้าเว็บได้

2 · errors.New() ต่างจาก fmt.Errorf() ยังไง

func Withdraw(balance, amount int) error {
    if amount > balance {
        return errors.New(
            "insufficient balance",
        )
    }
    return nil
}

func LoadConfig(filename string) error {
    data, err := os.ReadFile(filename)
    if err != nil {
        return fmt.Errorf(
            "read config %q: %w", filename, err,
        )
    }
    _ = data
    return nil
}

3 · Sentinel Error — error ที่มีชื่อให้เทียบได้

ปัญหาที่หัวข้อนี้แก้: ชั้นบนอยากรู้ว่า “พังเพราะอะไร” จะได้ตัดสินใจถูก แต่ถ้าไปดูจากข้อความของ error วันไหนมีคนแก้ข้อความ โค้ดก็พังตาม
ทางออกคือประกาศตัว error ไว้ล่วงหน้าเป็นตัวแปรที่มีชื่อ แล้วเทียบที่ตัวมันเอง ไม่ใช่ที่ข้อความ · ตัวแปรแบบนี้เรียกว่า sentinel

package user

// นิยมประกาศระดับ package และตั้งชื่อขึ้นต้นด้วย Err
var (
    ErrUserNotFound     = errors.New("user not found")
    ErrEmailAlreadyUsed = errors.New("email already used")
    ErrPermissionDenied = errors.New("permission denied")
)

ประโยชน์คือผู้เรียกตัดสินใจจาก error ได้ โดยไม่ต้องเทียบข้อความ:

if err == user.ErrUserNotFound {       // ใช้ได้ แต่เปราะมาก
if errors.Is(err, user.ErrUserNotFound) {  // ✓ ใช้อันนี้เสมอ

if errors.Is(err, user.ErrUserNotFound) {
    // ตอบ 404
} else if errors.Is(err, user.ErrPermissionDenied) {
    // ตอบ 403
}

if err.Error() == "user not found" {   // ✗ อย่าทำ

4 · Error Chain — ห่อ error โดยไม่ทำต้นตอหาย

ระบบจริงมีหลายชั้น แต่ละชั้นควรเติมบริบทของตัวเองลงไป โดยไม่กลบข้อมูลของชั้นล่าง
ชั้นที่พูดถึงในโค้ดข้างล่างคือ repository (ชั้นที่คุยกับฐานข้อมูล) → service (ชั้นที่ตัดสินใจตามกฎของงาน) → handler (ชั้นที่รับคำขอจากผู้ใช้และตอบกลับ)

// Repository:
func (r UserRepository) Find(id string) (User, error) {
    user, err := queryDatabase(id)
    if err != nil {
        return User{}, fmt.Errorf("query user: %w", err)
    }
    return user, nil
}

// Service: เติมบริบทอีกชั้น
func (s UserService) GetProfile(id string) (User, error) {
    user, err := s.repository.Find(id)
    if err != nil {
        return User{}, fmt.Errorf("get profile %s: %w", id, err)
    }
    return user, nil
}

ข้อความสุดท้ายที่ handler เห็น:

  get profile U-101: query user: user not found
  └──── Service ────┘└─ Repository ─┘└─ ต้นตอ ─┘

แต่ละชั้นเติมคำนำหน้า ต้นตอยังอยู่ท้ายสุดเสมอ
และ errors.Is() ยังมองทะลุถึงต้นตอได้

err := fmt.Errorf("query user: %v", ErrUserNotFound)
                              //     ↑ %v ไม่ใช่ %w

fmt.Println(errors.Is(err, ErrUserNotFound))

5 · errors.Is กับ errors.As — คนละงานกัน

// errors.Is — เช็คว่าใช่ตัวนั้นไหม
err := FindUser("U-101")
if errors.Is(err, ErrUserNotFound) {
    fmt.Println("show 404 page")
}

// errors.As — ดึงตัวจริงออกมาใช้ field
// ⚠️ ชนิดของตัวแปรต้องตรงกับที่ "คืนมาจริง" — หัวข้อ 1 คืน ValidationError{} (ค่า)
var validationErr ValidationError

err := ValidateAge(-1)
if errors.As(err, &validationErr) {
    fmt.Println("invalid field:", validationErr.Field)
    //                              ↑ ได้ field มาใช้ต่อ
}

6 · Custom Error Struct — แบบที่ใช้จริงในโปรดักชัน

หัวข้อนี้เอาทุกอย่างมารวมกัน: แทนที่จะคืน error ที่มีแค่ข้อความ เราคืน struct ที่พกทุกอย่างที่ชั้นบนต้องใช้ตัดสินใจไปด้วย (โปรดักชัน = ระบบตัวจริงที่ผู้ใช้ใช้อยู่ ไม่ใช่เครื่องเราตอนพัฒนา)

type AppError struct {
    Op         string   // เกิดที่ไหน — "UserService.GetUser"
    Code       string   // รหัสให้เครื่องอ่าน — "USER_NOT_FOUND"
    HTTPStatus int      // ตอบ client ยังไง — 404
    Message    string   // ข้อความให้ "ผู้ใช้" อ่าน
    Err        error    // error เดิมที่ห่อไว้
}

func (e *AppError) Error() string {
    if e.Err != nil {
        return fmt.Sprintf("%s: %s: %v", e.Op, e.Message, e.Err)
    }
    return fmt.Sprintf("%s: %s", e.Op, e.Message)
}

// ⚠️ ขาดอันนี้ไม่ได้ — ไม่งั้น errors.Is/As มองทะลุไม่ได้
func (e *AppError) Unwrap() error {
    return e.Err
}

ใช้ที่ชั้น service

func GetUser(id string) (User, error) {
    user, err := repository.FindByID(id)
    if err != nil {
        if errors.Is(err, ErrUserNotFound) {
            return User{}, &AppError{
                Op:         "UserService.GetUser",
                Code:       "USER_NOT_FOUND",
                HTTPStatus: http.StatusNotFound,
                Message:    "ไม่พบผู้ใช้งาน",
                Err:        err,
            }
        }
        return User{}, &AppError{
            Op:         "UserService.GetUser",
            Code:       "INTERNAL_ERROR",
            HTTPStatus: http.StatusInternalServerError,
            Message:    "ไม่สามารถโหลดข้อมูลผู้ใช้ได้",
            Err:        err,
        }
    }
    return user, nil
}

ใช้ที่ชั้น handler

user, err := service.GetUser(id)
if err != nil {
    var appErr *AppError

    if errors.As(err, &appErr) {
        http.Error(w, appErr.Message, appErr.HTTPStatus)
        return
    }

    // error ที่ไม่รู้จัก — อย่าเผยรายละเอียดออกไป
    http.Error(w, "internal server error", http.StatusInternalServerError)
    return
}

ผลรันจริงของโครงนี้:

err.Error()  = UserService.GetUser: ไม่พบผู้ใช้งาน: query user U-101: user not found
errors.Is(err, ErrUserNotFound)  = true      ← ทะลุถึงต้นตอ
errors.As(err, &appErr)          = true
appErr.Code = USER_NOT_FOUND | HTTPStatus = 404

7 · กับดักร้ายแรง: nil ที่ไม่ nil

func doWork() error {
    var e *AppError = nil
    return e            // คืน pointer ที่เป็น nil
}

if doWork() == nil {
    fmt.Println("ไม่มี error")
} else {
    fmt.Println("มี error!")
}

┌──────────────┬────────────┐
│   *AppError  │    nil     │   ← ช่อง type ไม่ว่าง!
└──────────────┴────────────┘
interface จะ == nil ก็ต่อเมื่อ ทั้งสองช่อง ว่าง

func doWork() error {
    if somethingWrong {
        return &AppError{...}
    }
    return nil          // ✓ nil ของแท้
}

8 · ทดสอบความจำ

9 · ลงมือทำ

อ่านต่อจากต้นทาง

แหล่งหลักที่แนะนำ: Working with Errors in Go 1.13 — เขียนโดยทีม Go ตอนที่เพิ่ม %w/Is/As เข้ามา จึงอธิบายว่าแต่ละอันเกิดมาแก้ปัญหาอะไร ไม่ใช่แค่ syntax ประมาณ 15 นาที และเป็นแหล่งที่ควรอ่านก่อนออกแบบ error ของโปรเจกต์จริง

อ้างอิง

• Working with Errors in Go 1.13 — ที่มาของ %w, errors.Is, errors.As
• Error handling and Go — ปรัชญาว่าทำไม error เป็นค่า
• pkg.go.dev — errors — เอกสาร Is/As/Join
• Go Code Review Comments — Error Strings — ข้อความ error ควรหน้าตายังไง
• Effective Go — Errors