Les bases de l'imbrication de structs

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

L'imbrication de structures (struct embedding) est le mécanisme de Go permettant d'inclure un type struct à l'intérieur d'un autre. Au lieu d'utiliser un nom de champ, vous spécifiez simplement le type, et Go promeut les champs de la struct imbriquée vers la struct externe.

Voici la syntaxe de base :

type Address struct {
    City    string
    Country string
}

type Person struct {
    Name string
    Address  // incorporé - pas de nom de champ
}

Lorsque vous imbriquez Address dans Person, vous pouvez accéder aux champs imbriqués directement sur la structure externe :

func main() {
    p := Person{
        Name: "Alice",
        Address: Address{
            City:    "London",
            Country: "UK",
        },
    }
    
    fmt.Println(p.City)     // London - accès direct
    fmt.Println(p.Country)  // UK - accès direct
    fmt.Println(p.Address.City)  // fonctionne également
}

Remarquez comment p.City fonctionne sans écrire explicitement p.Address.City. Go promeut automatiquement les champs de la structure imbriquée, les rendant accessibles comme s'ils appartenaient à la structure externe. Vous pouvez toujours y accéder via le nom du type imbriqué si nécessaire.

Cela diffère des structures imbriquées classiques où vous devez toujours utiliser le nom du champ pour accéder aux champs internes. L'imbrication (embedding) crée une API plus plate et plus pratique tout en conservant le regroupement logique des données associées.

Défi

Facile

Construisons un système d'immatriculation de véhicules qui utilise l'imbrication de structures (struct embedding) pour créer un modèle de données propre et organisé. Vous séparerez les informations de contact des détails du véhicule tout en permettant un accès direct à tous les champs grâce à l'imbrication.

Vous organiserez votre code sur deux fichiers :

vehicle.go : Créez deux structures qui fonctionnent ensemble par imbrication :
- Une structure ContactInfo avec les champs OwnerName et Phone (tous deux des chaînes de caractères)
- Une structure Vehicle qui imbrique ContactInfo (sans nom de champ) et ajoute ses propres champs Make, Model, et Year
Créez également une méthode nommée Summary sur Vehicle qui retourne une chaîne formatée contenant toutes les informations sur le véhicule et le contact.
main.go : Lisez les détails du véhicule et du propriétaire à partir de l'entrée, créez une instance de Vehicle avec ContactInfo imbriqué, et démontrez l'accès aux champs imbriqués à la fois directement et via le nom du type imbriqué. Affichez le résumé du véhicule à la fin.

Les entrées suivantes seront fournies :

Ligne 1 : Nom du propriétaire
Ligne 2 : Numéro de téléphone
Ligne 3 : Marque du véhicule
Ligne 4 : Modèle du véhicule
Ligne 5 : Année (entier)

Votre méthode Summary doit retourner une chaîne dans ce format :

[Year] [Make] [Model] - Owner: [OwnerName], Phone: [Phone]

Dans votre fichier principal, démontrez la promotion de champ (field promotion) en affichant :

Le nom du propriétaire accédé directement sur le Vehicle (par exemple, v.OwnerName)
Le téléphone accédé via le type imbriqué (par exemple, v.ContactInfo.Phone)
Le résumé complet provenant de votre méthode Summary

Par exemple, avec Alice Smith, 555-1234, Toyota, Camry, et 2023, votre sortie devrait être :

Alice Smith
555-1234
2023 Toyota Camry - Owner: Alice Smith, Phone: 555-1234

Remarquez comment les deux modes d'accès fonctionnent — l'accès direct via la promotion de champ et l'accès explicite via le nom du type imbriqué — vous offrant ainsi une flexibilité dans la manipulation des données imbriquées.

Aide-mémoire

L'imbrication de structures (struct embedding) vous permet d'inclure un type de structure à l'intérieur d'un autre sans spécifier de nom de champ. Les champs de la structure imbriquée sont promus à la structure externe, ce qui les rend directement accessibles.

Syntaxe de base

type Address struct {
    City    string
    Country string
}

type Person struct {
    Name string
    Address  // embedded - no field name
}

Accès aux champs imbriqués

Vous pouvez accéder aux champs imbriqués de deux manières :

p := Person{
    Name: "Alice",
    Address: Address{
        City:    "London",
        Country: "UK",
    },
}

// Direct access (field promotion)
fmt.Println(p.City)     // London

// Through embedded type name
fmt.Println(p.Address.City)  // London

Go promeut automatiquement les champs de la structure imbriquée, permettant un accès direct comme s'ils appartenaient à la structure externe. Vous pouvez toujours y accéder via le nom du type imbriqué si nécessaire.

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Lire le nom du propriétaire
	ownerName, _ := reader.ReadString('\n')
	ownerName = strings.TrimSpace(ownerName)

	// Lire le numéro de téléphone
	phone, _ := reader.ReadString('\n')
	phone = strings.TrimSpace(phone)

	// Lire la marque du véhicule
	make, _ := reader.ReadString('\n')
	make = strings.TrimSpace(make)

	// Lire le modèle du véhicule
	model, _ := reader.ReadString('\n')
	model = strings.TrimSpace(model)

	// Lire l'année
	yearStr, _ := reader.ReadString('\n')
	yearStr = strings.TrimSpace(yearStr)
	year, _ := strconv.Atoi(yearStr)

	// TODO: Créer une instance de Vehicle avec ContactInfo incorporé
	// Utiliser les valeurs lues à partir de l'entrée ci-dessus

	// TODO: Afficher le nom du propriétaire accédé directement sur le Vehicle (promotion de champ)
	// Exemple: fmt.Println(v.OwnerName)

	// TODO: Afficher le téléphone accédé via le nom du type incorporé
	// Exemple: fmt.Println(v.ContactInfo.Phone)

	// TODO: Afficher le résumé complet en utilisant la méthode Summary
	// Exemple: fmt.Println(v.Summary())

	// Supprimer ces lignes une fois la solution implémentée
	_ = ownerName
	_ = phone
	_ = make
	_ = model
	_ = year
}