Menu

Eingebettete Structs

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

In Go kannst du eine Struktur in eine andere einbetten und so Kompositionsbeziehungen schaffen. Das ist Gos Ansatz zur Vererbung.

Definiere zwei Strukturen, wobei eine in die andere eingebettet ist:

type Address struct {
    city  string
    state string
}

type Person struct {
    name string
    age  int
    Address  // eingebettete Struktur (ohne Feldnamen)
}

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

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

Portland

Aufgabe

Anfänger

In dieser Herausforderung übst du, eingebettete Structs (Komposition) in Go zu verwenden.

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

Deine Aufgabe ist es, die Definition des Structs Person so zu vervollständigen, dass das Struct Address eingebettet wird. Die Ausgabeanweisungen in main lesen die Adressfelder bereits direkt aus der Person (person.Street, person.City, person.ZipCode); sie werden kompiliert, sobald Address eingebettet ist.

Probier es selbst

package main

import "fmt"

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

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

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

	// Informationen zur Person einschließlich der Adresse ausgeben
	fmt.Println("Name:", person.Name)
	fmt.Println("Age:", person.Age)
	
	// Die Adressfelder direkt aus der Person-Instanz ausgeben
	fmt.Println("Street:", person.Street)
	fmt.Println("City:", person.City)
	fmt.Println("ZipCode:", person.ZipCode)
}

Teste 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 World Println Go-Kommentare

4Vergleichs- und logische Operatoren

Vergleichsoperatoren – Teil 1 Vergleichsoperatoren – Teil 2 Logischer UND-Operator Logischer ODER-Operator Logischer NICHT-Operator Grundlagen der Operatorrangfolge Zusammenfassung – Vergleiche durchführen

7Kontrollfluss: Schleifen

Die `for`-Schleife erklärt `for`-Schleife – Grundlagen `for`-Schleife – nur Bedingung Das Schlüsselwort `break`Das Schlüsselwort `continue`Verschachtelte Schleifen Wiederholung – Aktionen wiederholen

10Zusammengesetzte Typen: Arrays

Einführung in Arrays Arrays deklarieren Arrays initialisieren Auf Array-Elemente zugreifen Array-Länge mit `len`Arrays durchlaufen Mehrdimensionale Arrays

13Zusammengesetzte Typen: Structs

Benutzerdefinierte Typen definieren Struct-Instanzen erstellen Auf Struct-Felder zugreifen Pointer auf Structs Structs initialisierenEingebettete StructsAnonyme Structs Rückblick – Benutzerdefinierte Datenstrukturen

2Variablen und grundlegende Datentypen

Was ist eine Variable Typinferenz mit `:=`Ganzzahlen (int)Gleitkommazahlen Boolesche Werte Zeichenketten Nullwerte Konstanten Namenskonventionen Rückblick – Variablen und Typen

5Grundlegende Ein- und Ausgabe

Formatierte Ausgabe Formatierungsverben Datentypen ausgeben Grundlegende Benutzereingaben erhalten Rückblick – Ein- und Ausgabe

8Funktionen

Funktionen verstehen Eine Funktion deklarieren Funktionen aufrufen Funktionsparameter Einen einzelnen Wert zurückgeben Mehrere Werte zurückgeben Benannte Rückgabewerte Grundlagen des Funktionsumfangs Rückblick – Wiederverwendbaren Code erstellen

11Zusammengesetzte Datentypen: Slices

Einführung in Slices Slice-Literale deklarieren Slices mit `make` erstellen Slice-Länge vs. Kapazität Auf Slice-Elemente zugreifen Elemente anhängen Vorhandene Slices/Arrays aufteilen Über Slices iterieren Slices kopieren Rückblick – Dynamische Listen

14Grundlegende Fehlerbehandlung

Das Konzept von Fehlern Das `error`-Interface Funktionen, die Fehler zurückgeben Auf Fehler prüfen Einfache Fehler erstellen Formatierte Fehler erstellen Grundlegende Fehlerbehandlung Zusammenfassung – Probleme behandeln

3Grundlegende Operatoren

Arithmetische Operatoren Divisionsoperator Der Modulo-Operator Zuweisungsoperator Erweiterte Zuweisungsoperatoren Inkrement und Dekrement Rückblick – Berechnungen

6Kontrollfluss: Bedingungen

Die `if`-Anweisung Das `else`-Schlüsselwort Das `else if`-Schlüsselwort Variablen-Shadowing in `if`Variablen initialisieren Die `switch`-Anweisung Switch mit Ausdrücken Switch ohne Ausdruck Das `fallthrough`-Schlüsselwort Zusammenfassung – Entscheidungen treffen

9Zeiger

Was ist ein Zeiger?Zeigervariablen deklarieren Der Adressoperator Zeiger dereferenzieren Zeiger in Funktionen verwenden Nil-Zeiger Rückblick – Zeiger verstehen

12Zusammengesetzte Datentypen: Maps

Einführung in Maps Map-Literale deklarieren Maps mit `make` erstellen Schlüssel-Wert-Paare hinzufügen und aktualisieren Auf Map-Werte zugreifen Das Vorhandensein eines Schlüssels prüfen Map-Einträge löschen Länge von Maps Maps durchlaufen Zusammenfassung – Schlüssel-Wert-Speicherung

Übe selbstständig: Online-Go-Compiler