type assertion และ type switch คืออะไร?

Question

Accepted Answer

**type assertion** ดึงชนิดข้อมูล concrete ออกจากค่า interface และ **type switch** แตกแขนงตามชนิดข้อมูลที่อยู่ภายใต้ interface มันคือวิธีที่คุณกู้คืนข้อมูลชนิดเฉพาะออกจาก interface (โดยเฉพาะ empty interface / `any`)

## type assertion — ดึงชนิด concrete

```go
var i interface{} = "hello"     // an interface holding a string

s := i.(string)                  // assert it's a string → s = "hello"
fmt.Println(s)

n := i.(int)                     // ❌ PANIC — i is not an int (wrong assertion)
```

syntax `i.(Type)` ยืนยันว่า interface `i` ถือค่าของ `Type` แล้วดึงมันออกมา แต่การ assert ที่ผิด **panic** ดังนั้นโดยปกติคุณจะใช้รูปแบบ comma-ok ที่ปลอดภัย

## รูปแบบ comma-ok ที่ปลอดภัย

```go
s, ok := i.(string)
if ok {
    fmt.Println("it's a string:", s)   // ok = true, s = the value
} else {
    fmt.Println("not a string")         // ok = false, s = zero value, NO panic
}
```

รูปแบบสองค่าจะคืนค่าพร้อมกับ boolean โดย `ok` เป็น false (แทนการ panic) หาก assertion ล้มเหลว **ควรใช้รูปแบบนี้เสมอ** เว้นแต่คุณจะมั่นใจในชนิดข้อมูล

## type switch — แตกแขนงตามชนิดที่เป็นไปได้หลายชนิด

```go
func describe(i interface{}) string {
    switch v := i.(type) {           // the special .(type) form, only in a switch
    case int:
        return fmt.Sprintf("int: %d (doubled: %d)", v, v*2)
    case string:
        return fmt.Sprintf("string of length %d", len(v))
    case bool:
        return fmt.Sprintf("bool: %t", v)
    case nil:
        return "nil value"
    default:
        return fmt.Sprintf("unknown type: %T", v)
    }
}

describe(42)        // "int: 42 (doubled: 84)"
describe("hi")      // "string of length 2"
```

รูปแบบ `switch v := i.(type)` ตรวจสอบชนิดที่อยู่ภายในและ bind `v` (โดยมีชนิดที่เหมาะสมในแต่ละ case) เป็นวิธีที่สะอาดในการจัดการ interface ที่อาจถือได้หลายชนิด

## การ assert ชนิด interface ได้ด้วย

```go
// assert that a value implements a specific interface
if w, ok := i.(io.Writer); ok {
    w.Write([]byte("data"))    // use it as an io.Writer if it satisfies that interface
}
```

## เมื่อไหร่ที่คุณต้องใช้สิ่งเหล่านี้

```text
✓ Processing values of unknown type (interface{}/any) — JSON, generic handlers
✓ Checking if a value implements an optional interface (e.g. io.Closer)
✓ Handling heterogeneous data
⚠️ Often a sign you could use generics or better-typed interfaces instead — don't overuse
```

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

type assertion และ type switch เป็นเครื่องมือที่จำเป็นสำหรับการทำงานกับค่า interface ทั้งการกู้คืนข้อมูลชนิด concrete ออกจาก `interface{}`/`any` หรือการตรวจสอบว่าค่าหนึ่งสอดคล้องกับ interface ใด interface หนึ่งหรือไม่

มันจำเป็นเมื่อจัดการข้อมูลที่มีชนิดไม่แน่นอนหรือหลากหลาย (การ parse JSON แบบ dynamic, การประมวลผลแบบ generic, การตรวจสอบ optional interface อย่าง "สิ่งนี้ implement io.Closer หรือไม่?")

การเข้าใจ **ความแตกต่างระหว่าง panic กับแบบปลอดภัย** เป็นเรื่องสำคัญ: assertion ธรรมดา `i.(T)` panic เมื่อชนิดไม่ตรง ขณะที่ **รูปแบบ comma-ok** `v, ok := i.(T)` รายงานความล้มเหลวได้อย่างปลอดภัย การใช้รูปแบบที่ปลอดภัยเป็นแนวทางสำคัญในการหลีกเลี่ยง crash ในขณะ runtime

type switch จัดการชนิดที่เป็นไปได้หลายชนิดได้อย่างสง่างาม

การรู้สิ่งเหล่านี้ (และการที่ใช้มากเกินไปมักเป็นสัญญาณว่าคุณควรหันไปใช้ generics หรือการออกแบบที่ระบุชนิดได้ดีกว่า) มีความสำคัญต่อ Go ที่ปลอดภัยและ idiomatic และเป็นหัวข้อสัมภาษณ์ที่พบบ่อย เพราะ interface และ empty interface เป็นหัวใจสำคัญของภาษา