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 avec zéro méthode. Puisque chaque type en Go possède au moins zéro méthode, chaque type satisfait automatiquement l'interface vide. Cela la rend capable 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 un alias pour interface{}. Ils sont complètement interchangeables, mais any est plus lisible.

var value any = "Go is awesome"

L'interface vide est utile lorsque vous devez manipuler des valeurs de types inconnus ou variés. 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 sur son type spécifique.

Vous ne pouvez pas appeler directement des méthodes ou accéder à des champs sans d'abord extraire le type sous-jacent. Les prochaines leçons aborderont la manière de récupérer le type concret à partir d'une interface vide en utilisant les assertions de type (type assertions) et les commutateurs de type (type switches).

Défi

Facile

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

Vous organiserez 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 retourne un pointeur vers une Box contenant cette valeur. Ajoutez une méthode Describe qui retourne une chaîne de caractères montrant ce qui est stocké dans la boîte.
main.go : Lisez différentes valeurs à partir de l'entrée, créez des boîtes contenant un entier, une chaîne de caractères 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 de type chaîne de caractères
Ligne 3 : Une valeur booléenne (true ou false)

Votre méthode Describe doit retourner une chaîne de caractères dans ce format :

Box contains: [value]

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

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

L'idée clé ici est que votre structure Box unique 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, et pourtant elles sont toutes du même type Box.

Aide-mémoire

L'interface vide (interface{}) est une interface avec zéro méthode. Comme chaque type en Go possède au moins zéro méthode, chaque type satisfait automatiquement l'interface vide, ce qui la rend capable 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 pour interface{}. Ils sont complètement interchangeables, mais any est plus lisible :

var value any = "Go is awesome"

L'interface vide est utile pour manipuler des valeurs de types inconnus ou variés. Les fonctions peuvent 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)
}

Compromis : Lorsqu'une valeur est stockée dans une interface vide, vous perdez l'accès aux informations de son type spécifique. Vous ne pouvez pas appeler directement des méthodes ou accéder à des champs sans d'abord extraire le type sous-jacent à l'aide d'assertions de type (type assertions) ou de commutateurs de type (type switches).

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 de la chaîne de caractères
	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())
}