Struct embedding (composition) ta aiki ta yaya?

Question

Accepted Answer

Go ba shi da **inheritance** — maimakon haka yana amfani da **composition** ta hanyar struct embedding. Ta hanyar shokewa struct (ko interface) a cikin wani, wajan nau'i ya samu filayen da hanyoyin nau'in ciki kai tsaye. Wannan shine amsa Go ga sake amfani da code, tare da fifita "has-a" composition kan "is-a" inheritance.

## 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 (rubuta kawai sunan nau'i, babu sunan fila) **yana haifar** filayen da hanyoyin nau'in embedded zuwa wajan struct — saboda haka `d.Name` da `d.Eat()` suna aiki kamar sun kasance nasu na `Dog`. Wannan ya ga kamar inheritance amma shi ne composition: `Dog` *yana da* `Animal`.

## Shadowa da hanyoyin promoted

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

Wajan nau'i zai iya ayyana hanya tare da sunan daidai don "override" (shadow) mataccen hanya; har yanzu zaka iya samun sunan embedded kai tsaye.

## Embedding interfaces (sosai a isa)

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

Interface embedding yana haɗa ƙananan interfaces zuwa manyan — ana amfani da shi a duk jiya a sigar library.

## Composition a gida da inheritance — falsafar 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
```

## Me yasa ya makara

Struct embedding shine tsarin Go na musamman don **sake amfani da code da composition**, tare da maye gurbin inheritance da aka sani a gefen yawancin OOP languages.

Ganewa shine mahimmi saboda shi ne yadda Go ke cim ma sake amfani (haifar filayen/hanyoyin embedded saboda wajan nau'i "yana karba" hali ta hanyar composition) yayin da yake jinkiri inherited's sanannun matsaloli (fragile base classes, zuriya maimakonci masu zafi, abubuwan da suka dani sosai).

Ya nuna jagorantaccen jimla **"composition over inheritance."** Embedding yana bayyana a gida-gida — shokewa structs don sake amfani, shokewa interfaces don gina manyan contracts (kamar `io.ReadWriter`), da shokewa don behavior mixin-style.

Ganin cewa Go ba shi da inheritance da cewa embedding shine niyantaccen sasshen jiya — da kuma method-promotion da shadowing rules — shi ne tushen ji don karanta da tsara idiomatic Go, da jigon interview mai gama jiya yana bambance ne da class-based languages.