Hvordan fungerer struct embedding (komposisjon)?

Question

Accepted Answer

Go har **ingen arv** — i stedet bruker det **komposisjon** via struct embedding. Ved å legge inn en struct (eller interface) inni en annen, får den ytre typen feltene og metodene fra den indre typen direkte. Dette er Gos svar på kodegjenbruk, som favoriserer "har-en"-komposisjon fremfor "er-en"-arv.

## Embedding av en 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 (å skrive bare typens navn, ingen feltnavn) **promoterer** den innebygde typens felter og metoder til den ytre structen — så `d.Name` og `d.Eat()` fungerer som om de tilhørte `Dog`. Dette ser ut som arv, men er komposisjon: `Dog` *har en* `Animal`.

## Overstyring av promoterte metoder

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

Den ytre typen kan definere en metode med samme navn for å "overstyrer" (skygge) den promoterte; du kan fortsatt nå den innebygde versjonen eksplisitt.

## Embedding av interfaces (veldig vanlig)

```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 komponerer små interfaces sammen til større — brukt gjennom hele standardbiblioteket.

## Komposisjon fremfor arv — Gos filosofi

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

## Hvorfor det betyr noe

Struct embedding er Gos distinktive mekanisme for **kodegjenbruk og komposisjon**, som erstatter arven som finnes i de fleste OOP-språk.

Å forstå det er essensielt fordi det er hvordan Go oppnår gjenbruk (promotering av innebygde felter/metoder slik at den ytre typen "arver" oppførsel gjennom komposisjon) mens det bevisst unngår arvens velkjente problemer (skjøre basisklasser, dype stive hierarkier, tett koblet).

Det kjennetegner det vidt anerkjente prinsippet **"komposisjon fremfor arv."** Embedding vises konstant — embedding av strukturer for gjenbruk, embedding av interfaces for å bygge større kontrakter (som `io.ReadWriter`), og embedding for mixin-stiloppførsel.

Å gjenkjenne at Go ikke har arv og at embedding er dets komposisjonelle alternativ — pluss reglene for metodepromoteringen og skyggeeffekten — er fundamentalt for å lese og utforme idiomatisk Go, og et vanlig emne i intervjuer gitt hvordan det skiller seg fra klassebaserte språk.