Verschachtelte Structs

Teil des Abschnitts Objektorientierte Programmierung der GO-Journey von Coddy — Lektion 16 von 107.

Eine verschachtelte Struct ist eine Struct, die eine andere benannte Struct als eines ihrer Felder enthält. Dies ermöglicht es Ihnen, komplexe, hierarchische Daten zu modellieren, indem Sie kleinere, wiederverwendbare Typen miteinander kombinieren.

type Address struct {
    Street string
    City   string
    ZIP    string
}

type Person struct {
    Name    string
    Age     int
    Address Address  // verschachteltes Struct
}

Um auf Felder in einem verschachtelten Struct zuzugreifen, verketten Sie die Feldnamen mit Punkten.

p := Person{
    Name: "Alice",
    Age:  30,
    Address: Address{
        Street: "123 Main St",
        City:   "Boston",
        ZIP:    "02101",
    },
}

fmt.Println(p.Address.City) // Boston

Verschachtelung fördert die Wiederverwendung von Code. Der Typ Address kann in mehreren Structs wie Person, Company oder Order verwendet werden, ohne Felder zu duplizieren. Dieser Ansatz spiegelt reale Beziehungen wider, in denen Entitäten andere Entitäten enthalten.

type Company struct {
    Name      string
    Employees int
    Address   Address  // derselbe Address-Typ wiederverwendet
}

Sie können Structs über mehrere Ebenen hinweg verschachteln, obwohl flache Hierarchien die Lesbarkeit verbessern. Verschachtelte Structs sind grundlegend für den Aufbau objektorientierter Datenmodelle in Go.

Aufgabe

Einfach

Lassen Sie uns ein Mitarbeiterverwaltungssystem erstellen, das zeigt, wie verschachtelte Structs dabei helfen, reale Hierarchien abzubilden. Sie werden eine Struktur erstellen, in der Mitarbeiter zu Abteilungen gehören und Abteilungen Standortinformationen haben.

Sie werden Ihren Code in zwei Dateien organisieren:

models.go: Definieren Sie drei Structs, die zusammenarbeiten:
- Location mit den Feldern Building (string) und Floor (int)
- Department mit Name (string) und einem verschachtelten Location-Feld
- Employee mit ID (int), Name (string), und einem verschachtelten Department-Feld
main.go: Lesen Sie Mitarbeiterinformationen aus der Eingabe ein, erstellen Sie einen Employee mit korrekt verschachtelten Structs und zeigen Sie das vollständige Mitarbeiterprofil an, indem Sie über die verschachtelte Struktur auf die Felder zugreifen.

Die folgenden Eingaben werden bereitgestellt:

Zeile 1: Mitarbeiter-ID (Integer)
Zeile 2: Mitarbeitername
Zeile 3: Abteilungsname
Zeile 4: Gebäudebezeichnung
Zeile 5: Stockwerksnummer (Integer)

Ausgabeformat:

Employee: [Name] (ID: [ID])
Department: [DepartmentName]
Location: [Building], Floor [Floor]

Zum Beispiel, gegeben 101, Alice Chen, Engineering, Tower A und 5, sollte Ihre Ausgabe wie folgt aussehen:

Employee: Alice Chen (ID: 101)
Department: Engineering
Location: Tower A, Floor 5

Greifen Sie auf die verschachtelten Felder mit der Punktnotation zu, um sich durch die Struct-Hierarchie zu hangeln (z. B. employee.Department.Location.Building).

Spickzettel

Ein verschachteltes Struct (nested struct) ist ein Struct, das ein anderes benanntes Struct als eines seiner Felder enthält. Dies ermöglicht es Ihnen, hierarchische Daten zu modellieren, indem Sie kleinere, wiederverwendbare Typen zusammensetzen.

Verschachtelte Structs definieren

type Address struct {
    Street string
    City   string
    ZIP    string
}

type Person struct {
    Name    string
    Age     int
    Address Address  // verschachteltes Struct
}

Zugriff auf verschachtelte Felder

Verwenden Sie die Punktnotation, um sich durch die Struct-Hierarchie zu navigieren:

p := Person{
    Name: "Alice",
    Age:  30,
    Address: Address{
        Street: "123 Main St",
        City:   "Boston",
        ZIP:    "02101",
    },
}

fmt.Println(p.Address.City) // Boston

Wiederverwendung von verschachtelten Structs

Derselbe verschachtelte Struct-Typ kann in mehreren übergeordneten Structs wiederverwendet werden:

type Company struct {
    Name      string
    Employees int
    Address   Address  // derselbe Address-Typ wird wiederverwendet
}

Verschachtelte Structs fördern die Wiederverwendung von Code und spiegeln reale Beziehungen wider, in denen Entitäten andere Entitäten enthalten. Sie können Structs über mehrere Ebenen tief verschachteln, wobei flache Hierarchien die Lesbarkeit verbessern.

Probier es selbst

package main

import "fmt"

func main() {
	// Mitarbeiterinformationen lesen
	var id int
	var name string
	var deptName string
	var building string
	var floor int

	fmt.Scanln(&id)
	fmt.Scanln(&name)
	fmt.Scanln(&deptName)
	fmt.Scanln(&building)
	fmt.Scanln(&floor)

	// TODO: Erstelle einen Employee mit korrekt verschachtelten Structs
	// Verwende die Structs Location, Department und Employee aus models.go
	// Initialisiere alle verschachtelten Felder mit den Eingabewerten

	// TODO: Gib das Mitarbeiterprofil in folgendem Format aus:
	// Employee: [Name] (ID: [ID])
	// Department: [DepartmentName]
	// Location: [Building], Floor [Floor]
	// Greife auf verschachtelte Felder über die Punktnotation zu (z. B. employee.Department.Location.Building)
}