Interface vide

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

Jusqu'à présent, vous avez travaillé avec des interfaces qui nécessitent des méthodes spécifiques, mais Go possède une interface spéciale qui est incroyablement flexible : l'interface vide, écrite sous la forme interface{}.

L'interface vide n'a aucune exigence de méthode, ce qui signifie que n'importe quel type en Go la satisfait automatiquement. Puisque chaque type implémente au moins zéro méthode, chaque type peut être assigné à 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 vous devez travailler avec des données de types inconnus ou variables. Vous pourriez rencontrer cela lors de la lecture de fichiers de configuration, de la gestion des entrées utilisateur ou lors de l'utilisation d'API qui renvoient différents types de données selon la situation.

Cependant, comme 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 significative. C'est là que les assertions de type (type assertions) et les commutateurs de type (type switches) (que vous découvrirez ensuite) deviennent des outils essentiels pour travailler en toute sécurité avec les valeurs interface{}.

Testez-vous

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

Testez-vous

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

Testez-vous

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

Défi

Facile

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

Vous recevrez deux entrées :

Une chaîne de caractères représentant le type de données (par exemple, "int", "string", "bool" ou "slice")
Une chaîne de caractères 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 prend un paramètre interface{} et affiche des informations sur la valeur
En fonction du type de données en entrée, convertir la chaîne de valeur vers le type Go approprié :
- Pour "int" : convertir en entier
- Pour "string" : utiliser comme chaîne de caractères
- Pour "bool" : convertir en booléen
- Pour "slice" : convertir les valeurs séparées par des virgules en une tranche (slice) d'entiers
Appeler la fonction processData avec la valeur convertie
À l'intérieur de processData, afficher la valeur et son type au format : "Value: [value], Type: [type]"

Pour l'entrée de type slice, 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{}, démontrant ainsi comment l'interface vide peut contenir des valeurs de n'importe quel type. Utilisez fmt.Printf avec les verbes de formatage %v et %T pour afficher respectivement la valeur et le type.

Aide-mémoire

L'interface vide interface{} n'a aucune exigence de méthode, ce qui signifie que n'importe quel type en Go la satisfait automatiquement :

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

L'interface vide est utile pour travailler avec des données de types inconnus ou variables, tels que des fichiers de configuration, des entrées utilisateur ou des API qui renvoient différents types de données.

Utilisez fmt.Printf avec les verbes de formatage %v et %T pour afficher la valeur et le type d'une variable interface{} :

fmt.Printf("Value: %v, Type: %T", value, value)

Aides à la conversion utiles de la bibliothèque standard :

import (
    "strconv"
    "strings"
)

// Convertir une chaîne en entier (int)
n, err := strconv.Atoi("42")       // n = 42

// Convertir une chaîne en booléen (bool)
b, err := strconv.ParseBool("true") // b = true

// Diviser une chaîne en une tranche (slice)
parts := strings.Split("a,b,c", ",") // ["a", "b", "c"]

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éer la fonction processData qui accepte interface{}
	// 2. Convertir valueStr au type approprié en fonction de dataType
	// 3. Appeler 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.

Interface vide

Aide-mémoire

Toutes les leçons de Logique & Flux