Structs imbriquées

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 16 sur 107.

Une structure imbriquée est une structure qui contient une autre structure nommée comme l'un de ses champs. Cela vous permet de modéliser des données complexes et hiérarchiques en composant ensemble des types plus petits et réutilisables.

type Address struct {
    Street string
    City   string
    ZIP    string
}

type Person struct {
    Name    string
    Age     int
    Address Address  // structure imbriquée
}

Pour accéder aux champs d'une structure imbriquée, vous enchaînez les noms des champs avec des points.

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

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

L'imbrication favorise la réutilisation du code. Le type Address peut être utilisé dans plusieurs structures comme Person, Company ou Order sans dupliquer les champs. Cette approche reflète les relations du monde réel où les entités contiennent d'autres entités.

type Company struct {
    Name      string
    Employees int
    Address   Address  // même type Address réutilisé
}

Vous pouvez imbriquer des structures sur plusieurs niveaux, bien que le maintien de hiérarchies peu profondes améliore la lisibilité. Les structures imbriquées sont fondamentales pour construire des modèles de données orientés objet en Go.

Défi

Facile

Construisons un système de gestion des employés qui démontre comment les structures imbriquées aident à modéliser les hiérarchies du monde réel. Vous allez créer une structure où les employés appartiennent à des départements, et les départements possèdent des informations de localisation.

Vous organiserez votre code sur deux fichiers :

models.go : Définissez trois structures qui fonctionnent ensemble :
- Location avec les champs Building (string) et Floor (int)
- Department avec un champ Name (string) et un champ Location imbriqué
- Employee avec les champs ID (int), Name (string), et un champ Department imbriqué
main.go : Lisez les informations de l'employé à partir de l'entrée, créez un Employee avec les structures correctement imbriquées, et affichez le profil complet de l'employé en accédant aux champs via la structure imbriquée.

Les entrées suivantes seront fournies :

Ligne 1 : ID de l'employé (entier)
Ligne 2 : Nom de l'employé
Ligne 3 : Nom du département
Ligne 4 : Nom du bâtiment
Ligne 5 : Numéro d'étage (entier)

Format de sortie :

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

Par exemple, avec 101, Alice Chen, Engineering, Tower A, et 5, votre sortie devrait être :

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

Accédez aux champs imbriqués en utilisant la notation par points pour naviguer dans la hiérarchie des structures (par exemple, employee.Department.Location.Building).

Aide-mémoire

Une structure imbriquée (nested struct) est une structure qui contient une autre structure nommée comme l'un de ses champs, vous permettant de modéliser des données hiérarchiques en composant des types plus petits et réutilisables.

Définir des structures imbriquées

type Address struct {
    Street string
    City   string
    ZIP    string
}

type Person struct {
    Name    string
    Age     int
    Address Address  // structure imbriquée
}

Accéder aux champs imbriqués

Utilisez la notation par points pour parcourir la hiérarchie des structures :

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

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

Réutiliser des structures imbriquées

Le même type de structure imbriquée peut être réutilisé dans plusieurs structures parentes :

type Company struct {
    Name      string
    Employees int
    Address   Address  // même type Address réutilisé
}

Les structures imbriquées favorisent la réutilisation du code et reflètent les relations du monde réel où des entités en contiennent d'autres. Vous pouvez imbriquer des structures sur plusieurs niveaux, bien que le maintien de hiérarchies peu profondes améliore la lisibilité.

Essayez vous-même

package main

import "fmt"

func main() {
	// Lire les informations de l'employé
	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: Créer un Employee avec des structs correctement imbriquées
	// Utiliser les structs Location, Department, et Employee de models.go
	// Initialiser tous les champs imbriqués avec les valeurs d'entrée

	// TODO: Imprimer le profil de l'employé en utilisant le format :
	// Employee: [Name] (ID: [ID])
	// Department: [DepartmentName]
	// Location: [Building], Floor [Floor]
	// Accéder aux champs imbriqués en utilisant la notation par points (ex: employee.Department.Location.Building)
}