struct embedding (composition) ทำงานอย่างไร?

Question

Accepted Answer

Go **ไม่มี inheritance** — แต่ใช้ **composition** ผ่าน struct embedding แทน โดยการฝัง (embed) struct หนึ่ง (หรือ interface) ไว้ในอีกตัวหนึ่ง ชนิดที่อยู่ภายนอกจะได้รับ field และ method ของชนิดที่อยู่ภายในมาโดยตรง นี่คือคำตอบของ Go สำหรับการนำโค้ดกลับมาใช้ใหม่ ที่นิยม composition แบบ "has-a" มากกว่า inheritance แบบ "is-a"

## การ embed struct

```go
type Animal struct {
    Name string
}
func (a Animal) Eat() string {
    return a.Name + " is eating"
}

type Dog struct {
    Animal    // EMBEDDED — no field name, just the type → composition
    Breed string
}

d := Dog{
    Animal: Animal{Name: "Rex"},
    Breed:  "Lab",
}

// Dog gets Animal's fields and methods PROMOTED — accessed directly
fmt.Println(d.Name)     // "Rex" — promoted from the embedded Animal
fmt.Println(d.Eat())    // "Rex is eating" — Animal's method, called on Dog
```

การ embed (เขียนเพียงชื่อชนิด ไม่มีชื่อ field) จะ **promote** field และ method ของชนิดที่ถูก embed ขึ้นมายัง struct ภายนอก — ดังนั้น `d.Name` และ `d.Eat()` จึงทำงานราวกับว่าเป็นของ `Dog` สิ่งนี้ดูเหมือน inheritance แต่เป็น composition: `Dog` *มี (has a)* `Animal`

## การ override method ที่ถูก promote

```go
func (d Dog) Eat() string {        // Dog defines its OWN Eat()
    return d.Name + " the dog eats noisily"
}
d.Eat()         // calls Dog's Eat (the outer one shadows the embedded one)
d.Animal.Eat()  // explicitly call the embedded Animal's Eat if needed
```

ชนิดภายนอกสามารถนิยาม method ที่มีชื่อเดียวกันเพื่อ "override" (บดบัง/shadow) method ที่ถูก promote ได้ และคุณยังเข้าถึงเวอร์ชันที่ถูก embed ได้อย่างชัดเจน

## การ embed interface (พบบ่อยมาก)

```go
// embed interfaces to compose larger ones
type Reader interface { Read(p []byte) (int, error) }
type Writer interface { Write(p []byte) (int, error) }

type ReadWriter interface {   // composed from both via embedding
    Reader
    Writer
}
// (this is exactly how io.ReadWriter is defined in the standard library)
```

การ embed interface ประกอบ interface เล็ก ๆ ขึ้นเป็น interface ที่ใหญ่กว่า — ใช้กันทั่วทั้งไลบรารีมาตรฐาน

## composition เหนือ inheritance — ปรัชญาของ Go

```text
No class hierarchies, no "extends". Instead:
  ✓ Embed to reuse fields/methods (has-a)
  ✓ Embed interfaces to compose behavior contracts
  ✓ Avoids the fragility, deep hierarchies, and tight coupling of inheritance
```

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

struct embedding เป็นกลไกที่เป็นเอกลักษณ์ของ Go สำหรับ **การนำโค้ดกลับมาใช้ใหม่และการ composition** ซึ่งมาแทน inheritance ที่พบในภาษา OOP ส่วนใหญ่

การเข้าใจมันเป็นสิ่งจำเป็น เพราะมันคือวิธีที่ Go ทำการ reuse (โดย promote field/method ที่ถูก embed ทำให้ชนิดภายนอก "สืบทอด" พฤติกรรมผ่าน composition) ในขณะที่จงใจหลีกเลี่ยงปัญหาที่รู้จักกันดีของ inheritance (fragile base class, ลำดับชั้นที่ลึกและแข็งทื่อ, การ coupling ที่แน่นเกินไป)

มันเป็นการสะท้อนหลักการที่ได้รับการยอมรับอย่างกว้างขวางว่า **"composition over inheritance"** การ embed ปรากฏอยู่ตลอด — embed struct เพื่อ reuse, embed interface เพื่อสร้างสัญญาที่ใหญ่กว่า (เช่น `io.ReadWriter`) และ embed เพื่อพฤติกรรมแบบ mixin

การตระหนักว่า Go ไม่มี inheritance และว่า embedding คือทางเลือกแบบ compositional ของมัน — รวมถึงกฎการ promote method และการ shadow — เป็นพื้นฐานสำหรับการอ่านและออกแบบ Go ที่เป็นสำนวน และเป็นหัวข้อสัมภาษณ์ที่พบบ่อยเนื่องจากความแตกต่างจากภาษาที่อิง class