error pattern และกับดัก := ที่ทำให้ค่าหาย

1 · Go คืน error เป็นค่า ไม่ใช่ throw

ก่อนอื่น: ฟังก์ชัน Go คืนค่าได้มากกว่าหนึ่งตัว — เขียน type ที่จะคืนไว้ในวงเล็บ คั่นด้วยจุลภาค เช่น (float64, error) แปลว่า "คืนตัวเลขหนึ่งตัว และสถานะข้อผิดพลาดอีกหนึ่งตัว"
ตอนเรียกใช้ก็รับด้วยตัวแปรสองตัวคั่นจุลภาคเช่นกัน: result, err := divide(10, 2) — ตัวซ้ายรับค่าแรก ตัวขวารับค่าที่สอง เรียงตามลำดับใน signature เสมอ
signature = บรรทัดหัวของฟังก์ชัน ที่บอกว่ารับอะไรเข้าไปและคืนอะไรออกมา (ในที่นี้คือ func divide(a, b float64) (float64, error) · พูดเคร่งครัดตามสเปกของ Go คำว่า signature หมายถึงเฉพาะส่วน (a, b float64) (float64, error) ไม่นับคำว่า func และไม่นับชื่อฟังก์ชัน)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("cannot divide by zero")
    }
    return a / b, nil
}

// เรียกใช้ — สำนวนมาตรฐานที่จะเจอทุกวัน
result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
    return
}
fmt.Println("Result:", result)

ถ้าฟังก์ชันไม่มีผลลัพธ์อื่นนอกจากสำเร็จ/ไม่สำเร็จ ก็คืนแค่ error ตัวเดียว แล้วรวมกับ short statement ได้เลย
short statement = ท่าที่เขียนคำสั่งหนึ่งบรรทัดไว้ในหัว if เลย แล้วคั่นด้วย ; ก่อนเงื่อนไข — เรียกฟังก์ชันกับเช็คผลจบในบรรทัดเดียว:

func saveUser(u User) error { ... }

if err := saveUser(user); err != nil {
    fmt.Println("save failed:", err)
    return
}

แบบนี้ err มีชีวิตแค่ในบล็อก if — ไม่ไปรกด้านนอก และกันเผลอเอา err เก่ามาใช้ซ้ำ
บล็อก = ช่วงโค้ดที่อยู่ในปีกกา { } คู่หนึ่ง · ตัวแปรที่เกิดในบล็อกไหน จะตายพร้อมปีกกาปิดของบล็อกนั้น
· นอกจากปีกกาที่เห็นด้วยตา หัวของ if / for / switch ที่มี short statement ก็นับเป็นบล็อกซ่อนอีกชั้นหนึ่งด้วย — err ตัวข้างบนจึงเกิดในบล็อกซ่อนนั้น ทำให้ทั้งฝั่ง if และฝั่ง else (ถ้ามี) มองเห็นมันได้ แต่โค้ดที่อยู่นอก if มองไม่เห็น
จำคำนี้ไว้ให้ดี เพราะหัวข้อ 3 ทั้งหัวข้อวนอยู่รอบเรื่องนี้

2 · Named return & naked return

// ตั้งชื่อ return value ได้
func divide(a, b float64) (result float64, err error) {
    if b == 0 {
        err = errors.New("cannot divide by zero")
        return          // ← naked return: คืน result, err ที่มีอยู่ตอนนั้น
    }
    result = a / b
    return
}

แต่ named return มีพลังพิเศษอีกอย่างที่คุ้มมาก — defer เข้าไปแก้มันได้ (เรื่องนี้อยู่ใน บทเรียน 08) ใช้ห่อ error ทุกจุด return ในครั้งเดียว:

func loadConfig(path string) (err error) {
    defer func() {
        if err != nil {
            err = fmt.Errorf("loadConfig %s: %w", path, err)
        }
    }()
    // ...มี return err อยู่ 5 จุด ทุกจุดถูกห่อให้อัตโนมัติ
}
// ได้: loadConfig app.yaml: file missing

%w ใน fmt.Errorf คือ "wrap" — เก็บ error เดิมไว้ข้างในให้ errors.Is / errors.As ตรวจได้ทีหลัง (ต่างจาก %v ที่แปลงเป็นข้อความอย่างเดียว)

3 · 💀 กับดักใหญ่: := ไม่ได้แปลว่า "สร้างใหม่" เสมอไป

var sum = 0

if true {
    sum := sum + 20
    fmt.Println("ข้างใน  =", sum)
}

fmt.Println("ข้างนอก =", sum)

ข้างใน  = 20
ข้างนอก = 0     ← ไม่ใช่ 20!

แก้ง่ายมาก — เปลี่ยน := เป็น =

if true {
    sum = sum + 20    // = ไม่ใช่ := → แก้ตัวนอกจริง
}
// ข้างนอก = 20 ✓

ทำไมถึงอันตราย: เวอร์ชัน err

อาการเดียวกันนี้เกิดกับ err ได้ และตรงนี้แหละที่ทำให้ production พัง

func process() error {
    var err error

    if needFile {
        file, err := os.Open("demo.txt")   // 💀 := สร้าง err ตัวใหม่!
        if err != nil {
            fmt.Println("Cannot open:", err)
        }
        _ = file
    }

    return err   // ← คืน nil เสมอ! error ที่เกิดจริงหายไปแล้ว
}

ทางแก้ 2 แบบ:

// 1) ประกาศตัวแปรใหม่แยกไว้ก่อน แล้วบรรทัดที่เรียกฟังก์ชันใช้ = ล้วน (ไม่มี :=)
var file *os.File     // type ของ "ไฟล์ที่เปิดค้างไว้" — เครื่องหมาย * จะอธิบายตอนเรียน pointer
file, err = os.Open("demo.txt")   // = ล้วน → err ตัวนอกถูกเซ็ตจริง

// 2) จัดการ error ให้จบในที่เดียวกับที่มันเกิด (แนะนำ — ตรงกับ guard clause)
file, err := os.Open("demo.txt")
if err != nil {
    return err       // ส่งออกไปเลย ไม่ต้องเก็บไว้ใช้ทีหลัง
}

หัวใจของแบบที่ 1 ไม่ได้อยู่ที่ *os.File แต่อยู่ที่ เมื่อไม่มีตัวแปรใหม่ทางซ้ายแล้ว ก็ใช้ = ได้ และ = ไม่มีวันสร้างตัวแปรใหม่มาบัง — ถ้าจำได้ข้อเดียว จำข้อนี้

go vet -vettool=$(which shadow) ./...

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

5 · ลงมือทำ

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

แหล่งหลักที่แนะนำ: Error handling and Go — บทความทางการที่อธิบายว่าทำไม Go ถึงเลือกคืน error เป็นค่า ต่อด้วย Working with Errors in Go 1.13 ถ้าอยากเข้าใจ %w, errors.Is, errors.As

อ้างอิง

• Error handling and Go — ทำไมถึงคืน error เป็นค่า
• Working with Errors in Go 1.13 — %w, errors.Is, errors.As
• Go spec — Short variable declarations — กฎ "redeclaration" ที่ทำให้ := reuse ตัวแปรได้เฉพาะใน scope เดียวกัน
• Effective Go — Named result parameters
• Go Code Review Comments — Don't Panic