Go Academy · Lektion

Anonyme Structs und Komposition

Embedding und codebasierte Wiederverwendung mit Structs

Lektion 4 von 413 Schritte

Anonyme Structs und Komposition ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Anonyme Structs

Ein anonymes Struct hat keinen benannten Typ. Es wird direkt definiert und eignet sich für kurzlebige Daten, tabellengesteuerte Tests und einmalige Gruppierungen:

package main
import "fmt"

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

Anonyme Structs in Tabellentests

Ein verbreitetes Go-Idiom verwendet für tabellengesteuerte Tests einen Slice aus anonymen Structs:

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

Wenn Sie einen Typ in ein Struct einbetten, werden seine Felder und Methoden im äußeren Struct sichtbar:

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
}

Mehrfaches Einbetten

Ein Struct kann mehrere Typen einbetten. Konflikte (gleiche Feld- oder Methodennamen) müssen explizit aufgelöst werden:

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
}

Einbettung und Vererbung

Go kennt keine Klassenvererbung. Einbettung ist Komposition:

Durch Einbettung werden Felder und Methoden sichtbar, aber der äußere Typ ist kein Subtyp
Sie können kein Dog übergeben, wenn ein Animal erwartet wird
Verwenden Sie Interfaces für Polymorphie und Einbettung zur Wiederverwendung von Code

Sichtbare Methoden überschreiben

Das äußere Struct kann eine eingebettete Methode durch eine eigene Methode überschreiben:

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

Anonymes Struct für Konfiguration

Verwenden Sie ein anonymes Struct, um zusammengehörige Konfiguration zu gruppieren, ohne einen benannten Typ zu definieren:

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

Ein Interface einbetten

Das Einbetten eines Interfaces in ein Struct ist für Mocking und Standardimplementierungen nützlich:

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
}

Fallstricke bei der Struct-Komposition

Achten Sie auf Folgendes:

Mehrdeutige Selektoren, wenn zwei eingebettete Typen denselben Feld- oder Methodennamen haben
Ein eingebetteter Nil-Pointer, der beim Aufruf seiner Methoden eine Panic verursacht
Die Einbettung ist keine Vererbung — Sie können den äußeren Typ nicht anstelle des eingebetteten Typs verwenden

Anonyme Structs vergleichen

Zwei anonyme Structs mit denselben Feldnamen und -typen können einander zugewiesen werden, wenn auch ihre Tags übereinstimmen:

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
}

Kurze Überprüfung

Was bewirkt das Einbetten eines Typs in ein Struct?

Beantworte es in der interaktiven Lektion

Zusammenfassung: Komposition

Die wichtigsten Erkenntnisse:

Anonyme Structs eignen sich hervorragend für Tabellentests und kurzlebige Daten
Durch Einbettung werden Felder und Methoden sichtbar — es handelt sich um Komposition, nicht um Vererbung
Äußere Typen können eingebettete Methoden überschreiben
Lösen Sie mehrdeutige Selektoren explizit auf
Verwenden Sie Interfaces für Polymorphie

Übungsaufgabe

Erstellen Sie ein TimestampedRecord-Struct, das ein Timestamp struct{ CreatedAt, UpdatedAt string } und ein Data struct{ Key, Value string } einbettet. Erzeugen Sie eine Instanz und geben Sie alle sichtbaren Felder aus.

Kostenlos starten

Lerne Go mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 51
Lektionen: 203

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Anonyme Structs und Komposition“ kostenlos?

Ja — der vollständige Text von „Anonyme Structs und Komposition“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Anonyme Structs und Komposition“?

Embedding und codebasierte Wiederverwendung mit Structs Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Anonyme Structs und Komposition“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy