Interface vide

Fait partie de la section Logique & Flux du Journey GO de Coddy. Leçon 16 sur 68.

Jusqu'à présent, tu as travaillé avec des interfaces qui exigent des méthodes spécifiques, mais Go possède une interface spéciale incroyablement flexible : l'interface vide, écrite interface{}.

L’interface vide n’impose aucune exigence de méthode, ce qui signifie que tout type en Go la satisfait automatiquement. Puisque chaque type implémente au minimum zéro méthode, tout type peut être affecté à une variable de type interface{} :

var anything interface{}
anything = 42        // int
anything = "hello"   // string
anything = true      // bool
anything = []int{1, 2, 3}  // slice

Cela rend interface{} extrêmement utile lorsque vous devez travailler avec des données dont les types sont inconnus ou variables. Vous pouvez rencontrer ce cas lors de la lecture de fichiers de configuration, du traitement des entrées utilisateur ou de l'utilisation d'API qui renvoient différents types de données selon la situation.

Cependant, puisque l’interface vide peut contenir n’importe quel type, vous devrez souvent déterminer quel type y est réellement stocké avant de pouvoir utiliser la valeur de manière pertinente. C’est là que les assertions de type et les commutateurs de type (que vous découvrirez ensuite) deviennent des outils essentiels pour travailler en toute sécurité avec les valeurs interface{}.

Défi

Facile

Dans ce défi, vous allez vous entraîner à utiliser l’interface vide en créant un processeur de données capable de gérer différents types de valeurs. Vous allez créer une fonction qui accepte un paramètre interface{} et traite différents types de données.

Vous recevrez deux entrées :

Une chaîne représentant le type de données (par exemple, "int", "string", "bool" ou "slice")
Une chaîne représentant la valeur réelle (par exemple, "42", "hello", "true" ou "1,2,3")

Votre tâche consiste à :

Créer une fonction appelée processData qui accepte un paramètre interface{} et affiche des informations sur la valeur
En fonction de l’entrée indiquant le type de données, convertir la chaîne de valeur vers le type Go approprié :
- Pour "int" : convertir en entier
- Pour "string" : l’utiliser comme chaîne
- Pour "bool" : convertir en booléen
- Pour "slice" : convertir les valeurs séparées par des virgules en une tranche d’entiers
Appeler la fonction processData avec la valeur convertie
Dans processData, afficher la valeur et son type au format : "Value: [value], Type: [type]"

Pour l’entrée de type tranche, la chaîne séparée par des virgules, comme "1,2,3", doit être convertie en []int{1, 2, 3}. La fonction doit fonctionner avec n’importe quel type puisqu’elle accepte interface{}, ce qui montre comment l’interface vide peut contenir des valeurs de n’importe quel type. Utilisez fmt.Printf avec les verbes de format %v et %T pour afficher respectivement la valeur et le type.

Essayez vous-même

package main

import (
	"fmt"
)

func main() {
	// Lire l'entrée
	var dataType string
	var valueStr string
	fmt.Scanln(&dataType)
	fmt.Scanln(&valueStr)
	
	// TODO: Écrivez votre code ci-dessous
	// 1. Créez la fonction processData qui accepte interface{}
	// 2. Convertissez valueStr au type approprié en fonction de dataType
	// 3. Appelez processData avec la valeur convertie
	
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logique & Flux

Entraînez-vous par vous-même : Compilateur Go en ligne