any, Type Assertion และการดึงของจริงออกมาจากกล่อง

1 · interface{} / any — กล่องที่ใส่อะไรก็ได้

interface{} คือ interface ที่ไม่ขอ method อะไรเลย → ทุก type ในโลกจึงผ่านเงื่อนไขนี้อัตโนมัติ ตั้งแต่ Go 1.18 มีชื่อสั้นกว่าให้ใช้ คือ any (จำจาก บทเรียน 09: type any = interface{} — เป็น alias คือชื่อเรียกแทน ของชิ้นเดียวกันที่มีสองชื่อ ไม่ใช่ type ใหม่ เขียนอันไหนก็ได้ผลเท่ากันเป๊ะ)

func describe(v any) {
    fmt.Printf("Value: %v, Type: %T\n", v, v)
}

describe("hello")        // Value: hello, Type: string
describe(42)             // Value: 42, Type: int
describe(true)           // Value: true, Type: bool
describe(Score(95.5))    // Value: 95.5, Type: main.Score

ตัวแปร any เก็บ สองอย่าง เสมอ:

   ┌───────────────┬───────────────┐
   │  type จริง    │   ค่าจริง     │
   ├───────────────┼───────────────┤
   │   string      │   "hello"     │
   └───────────────┴───────────────┘
        ↑ %T อ่านช่องนี้    ↑ %v อ่านช่องนี้

type assertion = ถามช่องซ้าย แล้วขอช่องขวาถ้าตรง

2 · Type Assertion — แบบดิบ (เสี่ยง panic)

var i any = "hello"
s := i.(string)     // syntax: x.(T)
fmt.Println(s)      // hello

var i any = "hello"
n := i.(int)
fmt.Println(n)

panic: interface conversion: interface {} is string, not int

3 · Comma-ok — แบบปลอดภัย ใช้อันนี้

var i any = "hello"

s, ok := i.(string)
if ok {
    fmt.Println("String value:", s)
} else {
    fmt.Println("Not a string")
}

// ผลรันจริงเมื่อ i เก็บ string อยู่:
s, ok := i.(string)   // s = "hello",  ok = true
n, ok := i.(int)      // n = 0,        ok = false  ← zero value ไม่ใช่ขยะ

4 · Type Switch — เช็คหลาย type ทีเดียว

ถ้าต้องเช็ค 5 type ด้วย comma-ok ก็จะได้ if ซ้อนกัน 5 ชั้น — ซึ่งเป็นสิ่งที่ บทเรียน 04 บอกให้เลิกทำ Go มีไวยากรณ์เฉพาะให้:

func printType(v any) {
    switch value := v.(type) {    // ← .(type) เขียนได้เฉพาะใน switch
    case string:
        fmt.Println("string:", value)   // value เป็น string ตรงนี้
    case int:
        fmt.Println("int:", value)      // value เป็น int ตรงนี้
    case bool:
        fmt.Println("bool:", value)
    default:
        fmt.Println("unknown type")
    }
}

// ผลรันจริง:
printType("hello")   // string: hello
printType(42)        // int: 42
printType(true)      // bool: true
printType(3.14)      // unknown type   ← float64 ไม่มี case

case int, int64:
    value + 1   // ✗ compile error

5 · Stringer — ทำไม fmt.Println ถึงรู้จัก struct ของคุณ

fmt ทำ type switch อยู่ข้างในนั่นเอง — มันเช็คว่าค่าที่รับมา implement interface นี้ไหม (implement = มี method ครบตามที่ interface ขอ):

// นิยามจริงใน package fmt:
type Stringer interface {
    String() string
}

type Person struct {
    Name    string
    Surname string
}

func (p Person) String() string {
    return fmt.Sprintf("%s %s",
        p.Name, p.Surname)
}

fmt.Println(p)
// Alice Wonder

type Person struct {
    Name    string
    Surname string
}





fmt.Println(p)
// {Alice Wonder}

ไม่ต้องบอก fmt เลยว่าคุณมี String() — duck typing จาก บทเรียน 10 ทำงานให้อัตโนมัติ นี่คือตัวอย่างที่ชัดที่สุดว่า implicit interface มีประโยชน์ยังไง: fmt เขียนขึ้นก่อนโค้ดคุณเกิดเป็นสิบปี แต่ยังทำงานกับ type ใหม่ได้

func (p Person) String() string {
    return fmt.Sprintf("%v", p)   // ✗ วนไม่รู้จบ → stack overflow
}

6 · Interface Embedding — ประกอบ interface จากชิ้นเล็ก

บทเรียน 10 บอกให้ทำ interface ให้เล็ก แล้วถ้าบางที่อยากได้ครบทุกอันล่ะ — ไม่ต้องพิมพ์ซ้ำ ใช้ embedding:

type Saver   interface { Save(data []byte) error }
type Loader  interface { Load(id string) ([]byte, error) }
type Deleter interface { Delete(id string) error }

type Storage interface {
    Saver          // ← ไม่ใช่ field แต่คือ "รวม method ของ Saver มาด้วย"
    Loader
    Deleter
}

Storage จึงมี 3 method โดยไม่ต้องเขียนซ้ำ และ type ที่ implement ครบทั้งสามก็เป็น Storage อัตโนมัติ:

type FileStorage struct{}

func (FileStorage) Save(data []byte) error         { return nil }
func (FileStorage) Load(id string) ([]byte, error) { return []byte("example"), nil }
func (FileStorage) Delete(id string) error       { return nil }

var s Storage = FileStorage{}   // ✓ ผ่าน

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

8 · ลงมือทำ

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

แหล่งหลักที่แนะนำ: A Tour of Go — Type assertions ถึงหน้า 18 (จบที่ Stringer พร้อมแบบฝึกหัดให้เขียนเอง) ประมาณ 10 นาที ส่วนถ้าอยากรู้ว่า interface เก็บ type+value ยังไงในหน่วยความจำจริง ๆ Go Data Structures: Interfaces ของ Russ Cox (หนึ่งในทีมหลักของ Go) อธิบายระดับ bit เลย — ยากกว่าที่ต้องรู้ตอนนี้ แต่เก็บไว้อ่านตอนสงสัยว่าทำไม interface ถึงเร็ว

อ้างอิง

• A Tour of Go — Type assertions & switches
• Go spec — Type assertions — กฎว่าเมื่อไหร่ panic
• Go spec — Type switches
• pkg.go.dev — fmt.Stringer — นิยามจริง 3 บรรทัด
• pkg.go.dev — io.ReadWriter — ตัวอย่าง interface embedding ในของจริง
• Russ Cox — Go Data Structures: Interfaces — interface หน้าตายังไงในหน่วยความจำ