Structs imbriqués

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 montre comment les structures imbriquées aident à modéliser les hiérarchies du monde réel. Vous allez créer une structure dans laquelle les employés appartiennent à des services, et les services disposent d’informations de localisation.

Vous allez organiser votre code sur deux fichiers :

models.go : définir trois structures qui fonctionnent ensemble :
- Location avec les champs Building (string) et Floor (int)
- Department avec Name (string) et un champ Location imbriqué
- Employee avec ID (int), Name (string) et un champ Department imbriqué
main.go : lire les informations sur l’employé depuis l’entrée, créer un Employee avec des structures correctement imbriquées et afficher le profil complet de l’employé en accédant aux champs à travers la structure imbriquée.

Les entrées suivantes seront fournies :

Ligne 1 : identifiant de l’employé (entier)
Ligne 2 : nom de l’employé
Ligne 3 : nom du service
Ligne 4 : nom du bâtiment
Ligne 5 : numéro de l’é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 à l’aide de la notation par points pour parcourir la hiérarchie des structures (par exemple, employee.Department.Location.Building).

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)
}