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 particulière incroyablement flexible : l’interface vide, qui s’écrit interface{}. Depuis Go 1.18, tu peux aussi l’écrire any, un alias intégré qui signifie exactement interface{}.

L’interface vide n’impose aucune exigence concernant les méthodes, ce qui signifie que tout type dans Go la satisfait automatiquement. Puisque chaque type n’implémente aucune méthode (au minimum), tout type peut être affecté à une variable 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 tu dois travailler avec des données de type inconnu ou variable. Tu peux rencontrer ce cas en lisant des fichiers de configuration, en traitant les entrées utilisateur ou en travaillant avec des API qui renvoient différents types de données selon la situation.

Cependant, comme l’interface vide peut contenir n’importe quel type, tu devras 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 instructions de sélection de type (que tu découvriras ensuite) deviennent des outils essentiels pour manipuler en toute sécurité les valeurs de interface{}.

Défi

Facile

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

Tu recevras 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 proprement dite (par exemple, "42", "hello", "true" ou "1,2,3")

Ta tâche consiste à :

Créer une fonction appelée processData qui prend un paramètre interface{} et affiche des informations sur la valeur
En fonction du type de données fourni, convertir la chaîne représentant la valeur en type Go approprié :
- Pour "int" : convertir en entier
- Pour "string" : 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 contenant des valeurs séparées 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. Utilise 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 les données d’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 dans le 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