Menu

Deutsch

Eingebettete Structs

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

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

Definiere zwei Structs, wobei eines in das 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 Struktur zugreifen können:

Portland

Aufgabe

Anfänger

In dieser Herausforderung übst du die Verwendung eingebetteter Structs (Komposition) in Go.

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 zu vervollständigen, sodass es das Struct Address einbettet. Die Print-Anweisungen in main lesen die Adressfelder bereits direkt aus der Person (person.Street, person.City, person.ZipCode); sie lassen sich kompilieren, sobald Address eingebettet ist.

Probier es selbst

package main

import "fmt"

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

// Das Struct Person soll das Struct Address einbetten
type Person struct {
	Name string
	Age  int
	// TODO: Das Struct Address 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",
		},
	}

	// Personeninformationen einschließlich der Adresse ausgeben
	fmt.Println("Name:", person.Name)
	fmt.Println("Age:", person.Age)
	
	// Die Adressfelder direkt aus der Instanz von Person 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