Menu
Coddy logo textTech
JETZT LERNEN
flag De iconDeutschdown icon

Eingebettete Structs

Teil des Abschnitts Grundlagen der GO-Journey von Coddy — Lektion 99 von 109.

Go ermöglicht es Ihnen, ein struct in ein anderes einzubetten und so Kompositionsbeziehungen zu erstellen. Dies ist Gos Ansatz zur Vererbung.

Definieren Sie zwei Structs, wobei eines in das andere eingebettet ist:

type Address struct {
    city  string
    state string
}

type Person struct {
    name string
    age  int
    Address  // eingebettetes Struct (kein Feldname)
}

func main() {
    person := Person{
        name: "Alice",
        age: 30,
        Address: Address{city: "Portland", state: "Oregon"},
    }
    
    // Felder direkt ansprechen
    fmt.Println(person.city)  // Zugriff auf eingebettetes Feld
}

Die Ausgabe zeigt, dass wir direkt auf die Felder des eingebetteten Structs zugreifen können:

Portland
challenge icon

Aufgabe

Anfänger

In dieser Herausforderung wirst du den Einsatz von eingebetteten Structs (Komposition) in Go üben.

Wir haben zwei Structs: Address und Person. Das Person-Struct soll das Address-Struct einbetten, sodass eine Person direkt auf die Adressfelder zugreifen kann.

Deine Aufgabe ist es, die Definition des Person-Structs zu vervollständigen, um das Address-Struct einzubetten, und dann direkt von der Person-Instanz auf die Adressfelder zuzugreifen.

Spickzettel

Go verwendet Struct-Embedding für Komposition. Betten Sie ein Struct in ein anderes ein, indem Sie den Struct-Typ ohne Feldnamen angeben:

type Address struct {
    city  string
    state string
}

type Person struct {
    name string
    age  int
    Address  // eingebettetes Struct (kein Feldname)
}

Greifen Sie direkt auf die Felder des eingebetteten Structs zu:

person := Person{
    name: "Alice",
    age: 30,
    Address: Address{city: "Portland", state: "Oregon"},
}

fmt.Println(person.city)  // Direkter Zugriff auf das eingebettete Feld

Probier es selbst

package main

import "fmt"

// Address struct enthält Standortinformationen
type Address struct {
	Street  string
	City    string
	ZipCode string
}

// Person struct sollte das Address struct einbetten
type Person struct {
	Name string
	Age  int
	// TODO: Bette das Address struct hier ein (nur eine Zeile)
}

func main() {
	// Erstelle eine neue Person mit Adressinformationen
	person := Person{
		Name: "Alice",
		Age:  30,
		Address: Address{
			Street:  "123 Main St",
			City:    "Wonderland",
			ZipCode: "12345",
		},
	}

	// Drucke Personeninformationen einschließlich der Adresse
	fmt.Println("Name:", person.Name)
	fmt.Println("Age:", person.Age)
	
	// TODO: Drucke die Adressfelder direkt von der person Instanz aus
	// (ohne person.Address.Street usw. zu verwenden)
	fmt.Println("Street:", person.Street)
	fmt.Println("City:", person.City)
	fmt.Println("ZipCode:", person.ZipCode)
}
quiz iconTeste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Grundlagen

1Einführung in Go

Was ist Go?Hello WorldPrintlnGo-Kommentare

4Vergleichs- & logische Operatoren

Vergleichsoperatoren - Teil 1Vergleichsoperatoren - Teil 2Logischer UND-OperatorLogischer ODER-OperatorLogischer NICHT-OperatorGrundlagen der OperatorrangfolgeZusammenfassung - Vergleiche anstellen

7Kontrollfluss: Schleifen

Die `for`-Schleife erklärtfor-Schleife - Grundlagenfor-Schleife - Nur BedingungDas `break`-SchlüsselwortDas `continue`-SchlüsselwortVerschachtelte SchleifenZusammenfassung - Aktionen wiederholen

10Zusammengesetzte Typen: Arrays

Einführung in ArraysDeklarieren von ArraysInitialisieren von ArraysZugriff auf Array-ElementeArray-Länge mit `len`Iterieren über ArraysMehrdimensionale Arrays

13Zusammengesetzte Typen: Structs

Benutzerdefinierte Typen definierenStruct-Instanzen erstellenZugriff auf Struct-FelderPointer auf StructsStructs initialisierenEingebettete StructsAnonyme StructsZusammenfassung – Benutzerdefinierte Datenstrukturen

2Variablen und grundlegende Datentypen

Was ist eine VariableTypinferenz mit `:=`Ganzzahlen (int)GleitkommazahlenBoolesche WerteStringsZero ValuesKonstantenNamenskonventionenZusammenfassung - Variablen und Typen

5Grundlagen der Ein- und Ausgabe

Formatierte AusgabeFormat-VerbenTypen ausgebenEinfache Benutzereingaben erhaltenZusammenfassung – Ein- und Ausgabe

8Funktionen

Funktionen verstehenEine Funktion deklarierenFunktionen aufrufenFunktionsparameterEinen einzelnen Wert zurückgebenMehrere Werte zurückgebenBenannte RückgabewerteGrundlagen des Funktions-ScopesZusammenfassung – Wiederverwendbaren Code erstellen

11Zusammengesetzte Typen: Slices

Einführung in SlicesDeklaration von Slice-LiteralenSlices mit `make` erstellenSlice-Länge vs. KapazitätZugriff auf Slice-ElementeElemente anhängenSlicing von bestehenden Slices/ArraysIterieren über SlicesKopieren von SlicesZusammenfassung – Dynamische Listen

14Grundlagen der Fehlerbehandlung

Das Konzept von FehlernDas `error`-InterfaceFunktionen, die Fehler zurückgebenFehler prüfenEinfache Fehler erstellenFormatierte Fehler erstellenGrundlagen der FehlerbehandlungZusammenfassung – Probleme behandeln

3Grundlegende Operatoren

Arithmetische OperatorenDivisionsoperatorDer Modulo-OperatorZuweisungsoperatorKombinierte ZuweisungsoperatorenInkrement und DekrementZusammenfassung - Berechnungen

6Kontrollfluss: Bedingte Anweisungen

Die `if`-AnweisungDas `else`-SchlüsselwortDas `else if`-SchlüsselwortVariable Shadowing in `if`Variablen initialisierenDie `switch`-AnweisungSwitch mit AusdrückenSwitch ohne AusdruckDas `fallthrough`-SchlüsselwortZusammenfassung – Entscheidungen treffen

9Zeiger

Was ist ein Zeiger?Deklarieren von ZeigervariablenDer AdressoperatorDereferenzieren von ZeigernVerwendung von Zeigern in FunktionenNil-ZeigerZusammenfassung – Zeiger verstehen

12Zusammengesetzte Typen: Maps

Einführung in MapsDeklarieren von Map-LiteralenErstellen von Maps mit `make`Hinzufügen und Aktualisieren von Key-Value-PaarenZugriff auf Map-WerteÜberprüfen der Existenz von SchlüsselnLöschen von Map-EinträgenMap-LängeIterieren über MapsZusammenfassung – Key-Value-Speicher