Interface vide (any)

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

L’interface vide est une interface qui ne possède aucune méthode. Puisque chaque type en Go possède au moins zéro méthode, tout type satisfait automatiquement l’interface vide. Cela lui permet de contenir des valeurs de n’importe quel type.

var anything interface{}

anything = 42
anything = "hello"
anything = true
anything = []int{1, 2, 3}

À partir de Go 1.18, le mot-clé any a été introduit comme alias de interface{}. Ils sont totalement interchangeables, mais any est plus lisible.

var value any = "Go is awesome"

L’interface vide est utile lorsque vous devez gérer des valeurs de types inconnus ou variables. Des fonctions comme fmt.Println l’utilisent pour accepter des arguments de n’importe quel type :

func PrintAnything(v any) {
    fmt.Println("Value:", v)
}

func main() {
    PrintAnything(100)
    PrintAnything("text")
    PrintAnything(3.14)
}

Cependant, il y a un compromis. Lorsqu’une valeur est stockée dans une interface vide, vous perdez l’accès aux informations spécifiques sur son type.

Vous ne pouvez pas appeler directement des méthodes ni accéder à des champs sans extraire d’abord le type sous-jacent. Les prochaines leçons expliqueront comment récupérer le type concret d’une interface vide à l’aide d’assertions de type et de commutateurs de type.

Défi

Facile

Construisons un conteneur de stockage flexible capable de contenir des valeurs de n'importe quel type à l'aide de l'interface vide. Vous allez créer une boîte simple qui montre comment any vous permet de stocker différents types dans la même structure.

Vous allez organiser votre code sur deux fichiers :

box.go : définissez une structure Box avec un seul champ Content de type any. Créez une fonction constructeur NewBox qui accepte une valeur de n'importe quel type et renvoie un pointeur vers une Box contenant cette valeur. Ajoutez une méthode Describe qui renvoie une chaîne indiquant ce qui est stocké dans la boîte.
main.go : lisez différentes valeurs depuis l'entrée, créez des boîtes contenant un entier, une chaîne et un booléen, puis affichez la description de chaque boîte pour montrer comment le même type Box peut contenir des valeurs complètement différentes.

Les entrées suivantes seront fournies :

Ligne 1 : une valeur entière
Ligne 2 : une valeur chaîne
Ligne 3 : une valeur booléenne (true ou false)

Votre méthode Describe doit renvoyer une chaîne dans ce format :

Box contains: [value]

Par exemple, avec 42, hello et true, votre sortie doit être :

Box contains: 42
Box contains: hello
Box contains: true

L'idée essentielle ici est que votre unique structure Box peut stocker un entier, une chaîne ou un booléen : tout cela parce que le type any accepte des valeurs de n'importe quel type. Chaque boîte contient quelque chose de différent, mais elles sont toutes du même type Box.

Essayez vous-même

package main

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

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

	// Lire la valeur entière
	line1, _ := reader.ReadString('\n')
	intVal, _ := strconv.Atoi(strings.TrimSpace(line1))

	// Lire la valeur chaîne
	line2, _ := reader.ReadString('\n')
	strVal := strings.TrimSpace(line2)

	// Lire la valeur booléenne
	line3, _ := reader.ReadString('\n')
	boolVal, _ := strconv.ParseBool(strings.TrimSpace(line3))

	// TODO: Créer des boîtes pour chaque valeur en utilisant NewBox
	// TODO: Afficher la description de chaque boîte en utilisant la méthode Describe

	// Utiliser les variables pour éviter les erreurs de compilation (supprimer ces lignes lors de l'implémentation)
	_ = intVal
	_ = strVal
	_ = boolVal

	// Exemple de format de sortie :
	// fmt.Println(box.Describe())
}