Bagaimanakah embedding struct (composition) berfungsi?

Question

Accepted Answer

Go **tidak mempunyai inheritance** — sebaliknya ia menggunakan **composition** melalui embedding struct. Dengan menanam satu struct (atau interface) di dalam struct lain, jenis luar mendapatkan field dan method jenis dalam secara langsung. Ini adalah jawaban Go untuk penggunaan semula kod, memilih komposisi "has-a" berbanding inheritance "is-a".

## Embedding 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
```

Embedding (menulis hanya nama jenis, tanpa nama field) **mempromosikan** field dan method jenis tertanam ke struct luar — jadi `d.Name` dan `d.Eat()` berfungsi seolah-olah mereka milik `Dog`. Ini terlihat seperti inheritance tetapi adalah composition: `Dog` *mempunyai* `Animal`.

## Mengatasi method yang dipromosikan

```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
```

Jenis luar boleh mentakrifkan method dengan nama yang sama untuk "shadow" yang dipromosikan; anda masih boleh mencapai versi tertanam dengan jelas.

## Embedding interface (sangat biasa)

```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)
```

Embedding interface menggabungkan interface kecil menjadi yang lebih besar — digunakan di seluruh perpustakaan standard.

## Composition over inheritance — falsafah 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
```

## Mengapa ia penting

Embedding struct adalah mekanisme Go yang khas untuk **penggunaan semula kod dan composition**, menggantikan inheritance yang ditemui dalam kebanyakan bahasa OOP.

Memahaminya adalah penting kerana ini adalah bagaimana Go mencapai penggunaan semula (mempromosikan field/method tertanam supaya jenis luar "mewarisi" tingkah laku melalui composition) sambil dengan sengaja mengelakkan masalah warisan yang terkenal (kelas asas yang rapuh, hirarki yang kaku dalam, gandingan ketat).

Ia mewujudkan prinsip yang diiktiraf secara luas **"composition over inheritance."** Embedding muncul secara berterusan — embedding struct untuk penggunaan semula, embedding interface untuk membina kontrak yang lebih besar (seperti `io.ReadWriter`), dan embedding untuk tingkah laku gaya mixin.

Mengenali bahawa Go tidak mempunyai inheritance dan embedding adalah alternatif komposisionalnya — ditambah peraturan promosi dan shadowing method — adalah asas untuk membaca dan merancang Go idiomatik, dan topik temu duga yang biasa memandangkan bagaimana ia berbeza daripada bahasa berasaskan kelas.