Assertions de type

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

Lorsque vous travaillez avec des variables d’interface, vous devez souvent accéder à la valeur concrète réelle qui y est stockée. C’est là qu’interviennent les assertions de type : elles vous permettent d’extraire et d’utiliser en toute sécurité la valeur sous-jacente.

Une assertion de type utilise cette syntaxe : value, ok := interfaceVariable.(Type). La première valeur renvoyée est la valeur extraite du type spécifié, et la seconde est un booléen qui vous indique si l’assertion a réussi.

var data interface{} = 42

number, ok := data.(int)
if ok {
    fmt.Println("It's an integer:", number)
} else {
    fmt.Println("Not an integer")
}

La variable ok est essentielle pour la sécurité. Si tu essaies d’asserter le mauvais type, ok vaudra false, et value sera la valeur zéro de ce type. Sans vérifier ok, une assertion de type échouée provoquerait une panique dans ton programme.

Les assertions de type sont essentielles lorsque vous travaillez avec des valeurs interface{}, car elles vous permettent de reconvertir l’interface générique en un type spécifique afin de pouvoir utiliser ses méthodes et ses opérations.

Défi

Facile

Dans ce défi, vous allez vous entraîner à utiliser les assertions de type pour extraire et manipuler en toute sécurité des valeurs concrètes à partir de variables d’interface. Vous allez créer un analyseur de données qui traite différents types de valeurs stockées dans des interfaces vides.

Vous recevrez deux entrées :

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

Votre tâche consiste à :

Convertir la chaîne représentant la valeur vers le type Go approprié et la stocker dans une variable interface{} :
- Pour "int" : convertir en entier
- Pour "string" : l’utiliser comme chaîne
- Pour "bool" : convertir en booléen
Utiliser une assertion de type pour vérifier que la variable d’interface contient le type attendu indiqué dans la première entrée
Si l’assertion de type réussit, afficher : "Success: [value] is a [type]"
Si l’assertion de type échoue, afficher : "Failed: value is not a [type]"

Vous devez utiliser la syntaxe d’assertion de type sécurisée avec la variable ok pour vérifier si l’assertion a réussi. Ce défi teste votre compréhension de la manière d’extraire en toute sécurité des valeurs concrètes à partir de variables d’interface sans provoquer de panique dans votre programme.

Pour la conversion booléenne, "true" doit être converti en true et toute autre chaîne doit être convertie en false. Utilisez le package strconv pour convertir une chaîne en entier.

Essayez vous-même

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// Lire l'entrée
	var dataType string
	var valueStr string
	fmt.Scanln(&dataType)
	fmt.Scanln(&valueStr)
	
	// Variable pour stocker la valeur de l'interface
	var interfaceValue interface{}
	
	// TODO: Écrivez votre code ci-dessous
	// 1. Convertir valueStr au type approprié en fonction de dataType et stocker dans interfaceValue
	// 2. Utiliser l'assertion de type pour vérifier si interfaceValue contient le type attendu
	// 3. Imprimer le message de succès ou d'échec approprié
	
}

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