Type Switch

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

Si les assertions de type fonctionnent bien pour vérifier un seul type, vous devez souvent gérer plusieurs types possibles pour une variable d’interface. C’est là qu’un commutateur de type devient extrêmement utile : il permet d’effectuer différentes actions selon le type concret.

Un commutateur de type utilise cette syntaxe spéciale : switch v := i.(type). Remarque le mot-clé (type) à la place 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 a automatiquement le bon type : aucune assertion de type supplémentaire n’est nécessaire. Les commutations de type sont ainsi bien plus claires que l’enchaînement de plusieurs assertions de type avec des instructions if-else, surtout lorsque tu dois gérer plusieurs types différents au même endroit.

Défi

Facile

Dans ce défi, tu vas t’exercer à utiliser des commutateurs de type pour gérer plusieurs types de données dans un système de notifications. Tu vas créer une fonction qui traite différents types de notifications et les formate de manière appropriée en fonction de leur type concret.

Tu recevras deux entrées :

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

Ta tâche consiste à :

Créer une fonction appelée processNotification qui prend un paramètre interface{}
En fonction du type de notification reçu en entrée, convertir le contenu en type Go approprié et le stocker dans une variable interface{} :
- Pour "email" : utiliser le contenu comme chaîne
- Pour "sms" : convertir le contenu en entier (représentant le nombre de caractères)
- Pour "push" : convertir le contenu en booléen (true pour "enabled", false pour toute autre valeur)
- Pour "alert" : convertir le contenu en float64 (représentant le niveau de priorité)
Appeler la fonction processNotification avec la valeur convertie
Dans processNotification, utiliser un commutateur de type 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"

Utilise le package strconv pour les conversions de chaînes. Pour la conversion en booléen, seul "enabled" doit donner true. Ce défi montre comment les commutateurs de type offrent une manière claire de gérer plusieurs types dans une seule structure de contrôle, en te donnant automatiquement une valeur du type correct dans chaque cas.

Affiche le float64 sous sa forme la plus courte, comme le font fmt.Println ou les verbes %v / %g : 3.5 s’affiche sous la forme 3.5 et 1.0 sous la forme 1 (le verbe %f afficherait 1.000000).

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éez la fonction processNotification qui prend un paramètre de type interface{}
	// 2. Convertissez content vers le type approprié en fonction de notificationType
	// 3. Appelez processNotification avec la valeur convertie
	// 4. Utilisez un type switch dans 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.

Toutes les leçons de Logique & Flux

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