Hur fungerar struct-inbäddning (komposition)?

Question

Accepted Answer

Go har **ingen arv** — istället använder det **komposition** via struct-inbäddning. Genom att bädda in en struct (eller ett interface) inuti en annan får den yttre typen den inre typens fält och metoder direkt. Detta är Gos svar på kodåteranvändning, där "har-ett" komposition föredras framför "är-ett" arv.

## Bädda in 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
```

Inbäddning (att skriva bara typnamnet, inget fältnamn) **befordrar** den inbäddade typens fält och metoder till den yttre structen — så `d.Name` och `d.Eat()` fungerar som om de tillhörde `Dog`. Detta ser ut som arv men är komposition: `Dog` *har en* `Animal`.

## Åsidosätta befordrade 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 yttre typen kan definiera en metod med samma namn för att "åsidosätta" (skugga) den befordrade; du kan fortfarande nå den inbäddade versionen explicit.

## Bädda in interfaces (mycket vanligt)

```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-inbäddning komponerar små interfaces till större — används genomgående i standardbiblioteket.

## Komposition framför 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
```

## Varför det spelar roll

Struct-inbäddning är Gos särskilda mekanism för **kodåteranvändning och komposition**, som ersätter arvet som finns i de flesta OOP-språk.

Att förstå det är väsentligt eftersom det är hur Go uppnår återanvändning (befordra inbäddade fält/metoder så den yttre typen "ärver" beteende genom komposition) samtidigt som det medvetet undviker arvets välkända problem (ömtåliga basklasser, djupa stela hierarkier, tight koppling).

Det förkroppsligar den allmänt godkända principen **"komposition framför arv."** Inbäddning förekommer ständigt — inbäddade structs för återanvändning, inbäddade interfaces för att bygga större kontrakt (som `io.ReadWriter`), och inbäddning för mixin-stilbeteende.

Att inse att Go saknar arv och att inbäddning är dess kompositionella alternativ — plus metod-befordran- och skuggningsreglerna — är grundläggande för att läsa och utforma idiomatisk Go, och ett vanligt intervjuämne givet hur det skiljer sig från klassbaserade språk.