Bases de la réflexion

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 83 sur 107.

La réflexion permet à un programme d’examiner et de manipuler sa propre structure lors de l’exécution. Le package reflect de Go offre cette fonctionnalité, ce qui vous permet d’inspecter les types, de lire les champs des structures et d’appeler des méthodes dynamiquement.

Les deux types fondamentaux de la réflexion sont reflect.Type et reflect.Value. Vous les obtenez à l’aide de reflect.TypeOf() et reflect.ValueOf() :

import "reflect"

type Person struct {
    Name string
    Age  int
}

p := Person{Name: "Alice", Age: 30}

t := reflect.TypeOf(p)
v := reflect.ValueOf(p)

fmt.Println(t.Name())       // Person
fmt.Println(t.Kind())       // struct
fmt.Println(v.NumField())   // 2

Vous pouvez parcourir les champs d’une structure pour examiner leurs noms, types et valeurs :

for i := 0; i < t.NumField(); i++ {
    field := t.Field(i)
    value := v.Field(i)
    fmt.Printf("%s: %v\n", field.Name, value)
}
// Sortie :
// Name: Alice
// Age: 30

La réflexion est puissante, mais elle comporte des compromis : elle contourne la vérification des types à la compilation, s’exécute plus lentement qu’un accès direct et rend le code plus difficile à comprendre. Utilise-la avec parcimonie pour des tâches comme le marshaling JSON, le mapping ORM ou la création d’utilitaires génériques lorsque le type n’est pas connu à la compilation.

Défi

Facile

Construisons un inspecteur de structures qui utilise la réflexion pour examiner n’importe quelle structure et en rendre compte ! Il s’agit d’un cas d’utilisation pratique de la réflexion : créer des utilitaires qui fonctionnent avec des types inconnus au moment de la compilation.

Vous organiserez votre code sur deux fichiers :

inspector.go : créez votre utilitaire d’inspection fondé sur la réflexion.
Construisez une fonction InspectStruct(v any) string qui utilise le package reflect pour examiner toute structure qui lui est transmise. Votre fonction doit renvoyer un rapport mis en forme contenant :
- Le nom du type de la structure
- Le genre de la structure (doit être « struct »)
- Le nombre de champs
- Pour chaque champ : le nom du champ, son type et sa valeur actuelle
Le format de sortie doit être :
```
Type: [TypeName]
Kind: struct
Fields: [count]
- [FieldName] ([FieldType]): [Value]
- [FieldName] ([FieldType]): [Value]
...
```
Utilisez reflect.TypeOf() pour obtenir les informations de type et reflect.ValueOf() pour accéder aux valeurs des champs. Parcourez les champs en utilisant NumField() et Field(i) sur le type pour les métadonnées, ainsi que Field(i) sur la valeur pour les valeurs réelles.
main.go : définissez des structures d’exemple et utilisez votre inspecteur.
Lisez un type de structure (product ou employee) et les valeurs de ses champs, puis créez la structure appropriée et inspectez-la.

Pour product : créez une structure Product avec les champs Name (string), Price (float64) et InStock (bool). Lisez le nom, le prix et le statut des stocks.

Pour employee : créez une structure Employee avec les champs ID (int), Name (string) et Department (string). Lisez l’ID, le nom et le service.

Transmettez la structure créée à InspectStruct et affichez le résultat.

Les entrées suivantes seront fournies :

Ligne 1 : type de structure (product ou employee)
Lignes suivantes : valeurs des champs de ce type de structure

Par exemple, avec :

product
Laptop
999.99
true

Votre sortie doit être :

Type: Product
Kind: struct
Fields: 3
- Name (string): Laptop
- Price (float64): 999.99
- InStock (bool): true

Et avec :

employee
42
Alice Johnson
Engineering

Votre sortie doit être :

Type: Employee
Kind: struct
Fields: 3
- ID (int): 42
- Name (string): Alice Johnson
- Department (string): Engineering

Et avec :

product
Headphones
79.50
false

Votre sortie doit être :

Type: Product
Kind: struct
Fields: 3
- Name (string): Headphones
- Price (float64): 79.5
- InStock (bool): false

Remarquez comment votre inspecteur fonctionne avec différents types de structures sans connaître leur structure à l’avance. C’est toute la puissance de la réflexion ! La même fonction InspectStruct gère dynamiquement les structures Product et Employee.

Essayez vous-même

package main

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

// Structure Product avec les champs Name, Price et InStock
type Product struct {
	Name    string
	Price   float64
	InStock bool
}

// Structure Employee avec les champs ID, Name et Department
type Employee struct {
	ID         int
	Name       string
	Department string
}

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

	// Lire le type de structure
	structType, _ := reader.ReadString('\n')
	structType = strings.TrimSpace(structType)

	if structType == "product" {
		// Lire les champs du produit
		name, _ := reader.ReadString('\n')
		name = strings.TrimSpace(name)

		priceStr, _ := reader.ReadString('\n')
		priceStr = strings.TrimSpace(priceStr)
		price, _ := strconv.ParseFloat(priceStr, 64)

		inStockStr, _ := reader.ReadString('\n')
		inStockStr = strings.TrimSpace(inStockStr)
		inStock, _ := strconv.ParseBool(inStockStr)

		// TODO: Créer une structure Product avec les valeurs lues
		// TODO: Appeler InspectStruct avec le produit et afficher le résultat

	} else if structType == "employee" {
		// Lire les champs de l'employé
		idStr, _ := reader.ReadString('\n')
		idStr = strings.TrimSpace(idStr)
		id, _ := strconv.Atoi(idStr)

		name, _ := reader.ReadString('\n')
		name = strings.TrimSpace(name)

		department, _ := reader.ReadString('\n')
		department = strings.TrimSpace(department)

		// TODO: Créer une structure Employee avec les valeurs lues
		// TODO: Appeler InspectStruct avec l'employé et afficher le résultat

	}
}