Type Switch

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

Alors que les assertions de type fonctionnent bien pour vérifier un type unique, vous avez souvent besoin de gérer plusieurs types possibles pour une variable d'interface. C'est là qu'un commutateur de type (type switch) devient incroyablement utile : il offre un moyen propre d'effectuer différentes actions en fonction du type concret.

Un switch de type utilise cette syntaxe spéciale : switch v := i.(type). Remarquez le mot-clé (type) au lieu d'un type spécifique. La variable v contiendra la valeur réelle avec son type concret dans chaque cas :

func describe(data interface{}) {
    switch v := data.(type) {
    case int:
        fmt.Printf("Integer: %d\n", v)
    case string:
        fmt.Printf("String: %s\n", v)
    case bool:
        fmt.Printf("Boolean: %t\n", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

Dans chaque cas, v possède automatiquement le type correct - aucune assertion de type supplémentaire n'est nécessaire. Cela rend les commutateurs de type (type switches) beaucoup plus propres que l'enchaînement de plusieurs assertions de type avec des instructions if-else, surtout lorsque vous devez gérer plusieurs types différents au même endroit.

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 à utiliser les commutateurs de type (type switches) pour gérer plusieurs types de données dans un système de notification. Vous créerez une fonction qui traite différents types de notifications et les formate de manière appropriée en fonction de leur type concret.

Vous recevrez deux entrées :

Une chaîne de caractères représentant le type de notification (par exemple, "email", "sms", "push", ou "alert")
Une chaîne de caractères représentant le contenu ou la valeur de la notification

Votre tâche consiste à :

Créer une fonction appelée processNotification qui prend un paramètre interface{}
En fonction du type de notification en entrée, convertir le contenu vers le type Go approprié et le stocker dans une variable interface{} :
- Pour "email" : utiliser le contenu comme une chaîne de caractères (string)
- Pour "sms" : convertir le contenu en un entier (représentant le nombre de caractères)
- Pour "push" : convertir le contenu en un booléen (true pour "enabled", false pour tout le reste)
- Pour "alert" : convertir le contenu en un float64 (représentant le niveau de priorité)
Appeler la fonction processNotification avec la valeur convertie
À l'intérieur de processNotification, utiliser un commutateur de type (type switch) pour gérer chaque type et afficher le message approprié :
- Pour string : "Email notification: [value]"
- Pour int : "SMS notification with [value] characters"
- Pour bool : "Push notifications: [value]"
- Pour float64 : "Alert with priority: [value]"
- Pour tout autre type : "Unknown notification type"

Utilisez le package strconv pour les conversions de chaînes. Pour la conversion booléenne, seul "enabled" doit donner true. Ce défi démontre comment les commutateurs de type offrent un moyen propre de gérer plusieurs types dans une structure de contrôle unique, en vous donnant automatiquement la valeur correctement typée dans chaque cas.

Aide-mémoire

Un switch de type (type switch) offre un moyen propre de gérer plusieurs types possibles pour une variable d'interface en utilisant la syntaxe switch v := i.(type) :

func describe(data interface{}) {
    switch v := data.(type) {
    case int:
        fmt.Printf("Integer: %d\n", v)
    case string:
        fmt.Printf("String: %s\n", v)
    case bool:
        fmt.Printf("Boolean: %t\n", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

Dans chaque cas, la variable v possède automatiquement le type concret correct, éliminant ainsi le besoin d'assertions de type supplémentaires.

Essayez vous-même

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// Lire l'entrée
	var notificationType string
	var content string
	fmt.Scanln(&notificationType)
	fmt.Scanln(&content)
	
	// TODO : Écrivez votre code ci-dessous
	// 1. Créer la fonction processNotification qui prend un paramètre interface{}
	// 2. Convertir le contenu au type approprié en fonction de notificationType
	// 3. Appeler processNotification avec la valeur convertie
	// 4. Utiliser un switch de type à l'intérieur de processNotification pour gérer les différents types
	
}

Testez-vous

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

Type Switch

Aide-mémoire

Toutes les leçons de Logique & Flux