Go Academy · Les

Anonieme structs en compositie

Embedding en hergebruik van code op basis van structs

Les 4 van 413 stappen

Anonieme structs en compositie is een gratis Go Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Go Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Go Academy bevat in totaal 4 lessen.

Anonieme structs

Een anonieme struct heeft geen benoemd type. Deze wordt inline gedefinieerd en is handig voor kortlevende gegevens, tabelgestuurde tests en eenmalige groeperingen:

package main
import "fmt"

func main() {
    point := struct{ X, Y int }{X: 3, Y: 7}
    fmt.Println(point.X, point.Y)
}

Anonieme structs in tabeltests

Een veelgebruikte Go-idiom gebruikt een slice van anonieme structs voor tabelgestuurde tests:

package main
import "fmt"

func double(n int) int { return n * 2 }

func main() {
    tests := []struct{ input, want int }{
        {1, 2}, {5, 10}, {0, 0},
    }
    for _, tt := range tests {
        got := double(tt.input)
        if got != tt.want {
            fmt.Printf("FAIL: double(%d) = %d, want %d\n", tt.input, got, tt.want)
        }
    }
    fmt.Println("all tests passed")
}

Struct embedding

Door een type in een struct te embedden, worden de velden en methoden ervan beschikbaar in de buitenste struct:

package main
import "fmt"

type Animal struct{ Name string }
func (a Animal) Speak() string { return a.Name + " speaks" }

type Dog struct {
    Animal        // embedded
    Breed string
}

func main() {
    d := Dog{Animal: Animal{"Rex"}, Breed: "Labrador"}
    fmt.Println(d.Name)    // promoted field
    fmt.Println(d.Speak()) // promoted method
}

Meerdere typen embedden

Een struct kan meerdere typen embedden. Conflicten (dezelfde veld- of methodenaam) moeten expliciet worden opgelost:

package main
import "fmt"

type Logger struct{}
func (Logger) Log(s string) { fmt.Println("[LOG]", s) }

type Metrics struct{}
func (Metrics) Count() int { return 42 }

type Service struct {
    Logger
    Metrics
    Name string
}

func main() {
    svc := Service{Name: "auth"}
    svc.Log("started")       // from Logger
    fmt.Println(svc.Count()) // from Metrics
}

Embedding versus overerving

Go heeft geen klasse-overerving. Embedding is compositie:

Embedding maakt velden en methoden beschikbaar, maar het buitenste type is geen subtype
Je kunt geen Dog doorgeven waar een Animal wordt verwacht
Gebruik interfaces voor polymorfisme en embedding voor hergebruik van code

Beschikbaar gemaakte methoden overschrijven

De buitenste struct kan een ingesloten methode verbergen door zelf een methode met die naam te definiëren:

package main
import "fmt"

type Base struct{}
func (Base) Hello() string { return "Base hello" }

type Child struct{ Base }
func (Child) Hello() string { return "Child hello" } // shadows Base.Hello

func main() {
    c := Child{}
    fmt.Println(c.Hello())      // Child hello
    fmt.Println(c.Base.Hello()) // Base hello (explicit)
}

Anonieme struct voor configuratie

Gebruik een anonieme struct om gerelateerde configuratie te groeperen zonder een benoemd type te definiëren:

package main
import "fmt"

func main() {
    cfg := struct {
        Host string
        Port int
        TLS  bool
    }{
        Host: "api.example.com",
        Port: 443,
        TLS:  true,
    }
    fmt.Println(cfg)
}

Een interface embedden

Een interface embedden in een struct is handig voor nabootsing en standaardimplementaties:

package main
import "fmt"

type Reader interface{ Read() string }

type Mock struct{ Reader }  // embed interface

func main() {
    m := Mock{}
    fmt.Printf("%T\n", m.Reader) // <nil> — not set
    // Assign a real impl at test time:
    _ = m
}

Valkuilen bij struct-compositie

Let op het volgende:

Onduidelijke selectors wanneer twee ingesloten typen dezelfde veld- of methodenaam hebben
Een nil-pointer in een ingesloten type kan een panic veroorzaken wanneer je er methoden op aanroept
Vergeet niet dat embedding geen overerving is — je kunt het buitenste type niet gebruiken als vervanging voor het ingesloten type

Anonieme structs vergelijken

Twee anonieme structs met dezelfde veldnamen en typen kunnen aan elkaar worden toegewezen als hun tags ook overeenkomen:

package main
import "fmt"

func main() {
    a := struct{ X, Y int }{1, 2}
    b := struct{ X, Y int }{1, 2}
    fmt.Println(a == b) // true
}

Korte controle

Wat bereik je door een type in een struct te embedden?

Beantwoord dit in de interactieve les

Samenvatting: compositie

Belangrijkste punten:

Anonieme structs zijn ideaal voor tabeltests en kortlevende gegevens
Embedding maakt velden en methoden beschikbaar — het is compositie, geen overerving
Buitenste typen kunnen ingesloten methoden verbergen
Los onduidelijke selectors expliciet op
Gebruik interfaces voor polymorfisme

Oefenopdracht

Maak een TimestampedRecord-struct die een Timestamp struct{ CreatedAt, UpdatedAt string } en een Data struct{ Key, Value string } embedt. Maak er een instantie van en druk alle beschikbaar gemaakte velden af.

Gratis beginnen

Leer Go met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Anonieme structs en compositie” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Go Academy, waaronder “Anonieme structs en compositie”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Go Academy bevat in totaal 4 lessen.

Wat leer ik in “Anonieme structs en compositie”?

Embedding en hergebruik van code op basis van structs Je oefent met Go Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Go Academy te beginnen?

Ervaring vooraf is niet nodig. Go Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Anonieme structs en compositie”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Go Academy?

Ja. Elke les over Go Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Go Academy