Structs anonymes

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

Une structure anonyme est une structure sans type nommé. Vous définissez sa structure et créez une instance en une seule étape, sans utiliser le mot-clé type.

person := struct {
    Name string
    Age  int
}{
    Name: "Alice",
    Age:  30,
}

Cela crée directement une valeur de structure sans déclarer de type réutilisable. Les structures anonymes sont utiles lorsque vous avez besoin d’une structure de données rapide et ponctuelle qui ne sera pas utilisée ailleurs dans votre code.

Un cas d’utilisation courant consiste à regrouper des données liées pour une seule fonction ou un seul test.

config := struct {
    Host string
    Port int
}{
    Host: "localhost",
    Port: 8080,
}
fmt.Println(config.Host) // localhost

Les structures anonymes sont également populaires dans les tests pilotés par des tables, où chaque cas de test possède des champs uniques.

tests := []struct {
    input    int
    expected int
}{
    {1, 2},
    {5, 10},
}

Comme les structures anonymes n’ont pas de nom de type, vous ne pouvez pas définir de méthodes sur elles ni réutiliser le type ailleurs. Utilisez-les pour regrouper temporairement des données dans un contexte local. Pour tout élément auquel vous ferez référence plusieurs fois, définissez plutôt un type de structure nommé.

Défi

Facile

Construisons rapidement un système de configuration qui montre dans quels cas les structures anonymes sont particulièrement utiles, pour regrouper ponctuellement des données qui n’ont pas besoin d’un type réutilisable.

Vous organiserez votre code sur deux fichiers :

config.go : créez une fonction appelée GetServerConfig qui prend en paramètres un nom de serveur (string), un port (int) et le mode de débogage (bool). Cette fonction doit renvoyer une structure anonyme contenant ces trois valeurs dans les champs suivants : Name, Port et Debug. Comme cette configuration n’est utilisée qu’à un seul endroit, il n’est pas nécessaire de définir un type nommé pour celle-ci.
main.go : lisez les valeurs de configuration du serveur depuis l’entrée, appelez votre fonction GetServerConfig et affichez les détails de la configuration.

Les entrées suivantes seront fournies :

Ligne 1 : Nom du serveur
Ligne 2 : Numéro de port
Ligne 3 : Mode de débogage (true ou false)

Format de sortie :

Server: [Name]
Port: [Port]
Debug: [Debug]

Par exemple, avec api-server, 8080 et true, votre sortie doit être :

Server: api-server
Port: 8080
Debug: true

Remarquez comment la structure anonyme vous permet de renvoyer des données regroupées sans encombrer votre base de code avec un type qui n’est utilisé qu’une seule fois.

Essayez vous-même

package main

import (
	"fmt"
)

func main() {
	// Lire les valeurs d'entrée
	var name string
	var port int
	var debug bool

	fmt.Scanln(&name)
	fmt.Scanln(&port)
	fmt.Scanln(&debug)

	// TODO: Appeler GetServerConfig avec les valeurs d'entrée
	// et stocker la structure anonyme retournée

	// TODO: Afficher la configuration au format requis :
	// Serveur : [Name]
	// Port : [Port]
	// Debug : [Debug]
}