Go errors .Is กับ .As เป็นเพื่อนกัน

if err == sql.ErrNoRows {
    // handle
}

err := getUser()
// err = "GetUser: sql: no rows in result set"
// err == sql.ErrNoRows → false! เพราะมันถูก wrap แล้ว

import "fmt"

func getUser(id string) (*User, error) {
    user, err := db.QueryRow(...)
    if err != nil {
        return nil, fmt.Errorf("getUser(%s): %w", id, err)
        //                          ↑↑↑↑↑↑↑↑↑↑↑
        //                          wrap err ด้วย %w
    }
    return user, nil
}

original := sql.ErrNoRows
wrapped := fmt.Errorf("getUser: %w", original)

fmt.Println(wrapped.Error())
// "getUser: sql: no rows in result set"

// หน้าตาภายใน:
// wrapped = &wrapError{
//     msg: "getUser",
//     err: sql.ErrNoRows  ← เก็บ original ไว้!
// }

import "errors"

err := getUser("42")
// err = "getUser(42): sql: no rows in result set"

if errors.Is(err, sql.ErrNoRows) {
    // ✅ true — Is เดินตาม chain แล้วเจอ sql.ErrNoRows ข้างใน
    fmt.Println("not found")
}

1. เปรียบเทียบ err == sql.ErrNoRows? → false (คนละ type)
2. err มี Unwrap() ไหม? → มี (เพราะใช้ %w)
3. unwrap → "sql: no rows..."
4. เปรียบเทียบ unwrapped == sql.ErrNoRows? → ✅ true!
5. ตอบ true

// เช็คหลายระดับ
err := fmt.Errorf("handler: %w",
          fmt.Errorf("service: %w",
              sql.ErrNoRows))

errors.Is(err, sql.ErrNoRows) // ✅ true — ลงลึก 2 ชั้น

var pathErr *os.PathError

err := os.Open("/nonexistent/file")

if errors.As(err, &pathErr) {
    // ✅ true — err เป็น *os.PathError (หรือมี *os.PathError อยู่ใน chain)
    fmt.Println("path:", pathErr.Path)      // "/nonexistent/file"
    fmt.Println("op:", pathErr.Op)          // "open"
}

1. err เป็น *os.PathError? → ใช่!
2. ใส่ค่า err เข้าไปใน pathErr (ผ่าน pointer ที่ส่งเข้า)
3. ตอบ true

// ❌ ผิด — As ต้องการ pointer
if errors.As(err, os.PathError{}) { ... }

// ✅ ถูก — pointer to error type
var target *os.PathError
if errors.As(err, &target) { ... }

// ✅ ถูก — ใช้ interface ก็ได้
var netErr net.Error
if errors.As(err, &netErr) { ... }

Is → "Is this THAT error?" → เปรียบเทียบ value
As → "As WHAT type?" → ตรวจสอบ type + extract

func handleError(err error) {
    // 1. เช็คก่อนว่า "ใช่ not found ไหม?"
    if errors.Is(err, sql.ErrNoRows) {
        fmt.Println("not found")
        return
    }

    // 2. เช็คต่อว่า "เป็น path error ไหม?" — ถ้าใช่ ดูว่าไฟล์ไหน
    var pathErr *os.PathError
    if errors.As(err, &pathErr) {
        fmt.Printf("can't open %s\n", pathErr.Path)
        return
    }

    // 3. เช็ค transient network error
    var netErr net.Error
    if errors.As(err, &netErr) && netErr.Temporary() {
        fmt.Println("temporary — retry")
        return
    }

    fmt.Printf("unexpected: %v\n", err)
}

// 1. Sentinel error — ใช้กับ Is
var ErrPermission = errors.New("permission denied")

// 2. Custom error type — ใช้กับ As
type ValidationError struct {
    Field string
    Value any
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("invalid %s: %v", e.Field, e.Value)
}

// ใช้ Is กับ sentinel
if errors.Is(err, ErrPermission) {
    fmt.Println("no permission")
}

// ใช้ As กับ custom type
var valErr *ValidationError
if errors.As(err, &valErr) {
    fmt.Printf("field %s is invalid\n", valErr.Field)
}

Is  →  "Is this error the SAME as...?"
        → เปรียบเทียบค่า เหมือน == แต่เดิน chain ให้

As  →  "As WHAT TYPE?"
        → ตรวจ type + extract value เหมือน type assertion แต่เดิน chain ให้