Type Switch

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

Bien que les assertions de type soient efficaces pour vérifier un type unique, vous devez souvent gérer plusieurs types possibles pour une variable d’interface. C’est là qu’un type switch devient particulièrement utile : il offre une manière claire d’effectuer différentes actions en fonction du type concret.

Un commutateur de types utilise cette syntaxe spéciale : switch v := i.(type). Remarque 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 switchs de type bien plus clairs que l’enchaînement de plusieurs assertions de type avec des instructions if-else, en particulier lorsque vous devez gérer plusieurs types différents au même endroit.

Défi

Facile

Dans ce défi, vous allez vous entraîner à utiliser des commutateurs de type pour gérer plusieurs types de données dans un système de notifications. Vous allez 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.

Vous recevrez 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

Votre tâche consiste à :

Créer une fonction appelée processNotification qui prend un paramètre de type interface{}
Selon l’entrée du type de notification, convertir le contenu vers le type Go approprié et le stocker dans une variable de type 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 (vrai pour "enabled", faux 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"

Utilisez le package strconv pour les conversions de chaînes. Pour la conversion booléenne, seule la valeur "enabled" doit produire 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 vous fournissant automatiquement une valeur correctement typée dans chaque cas.

Affichez le float64 sous sa forme la plus courte, comme le font fmt.Println ou les verbes %v / %g : 3.5 s’affiche comme 3.5 et 1.0 comme 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. Create processNotification function that takes interface{} parameter
	// 2. Convert content to appropriate type based on notificationType
	// 3. Call processNotification with the converted value
	// 4. Use type switch inside processNotification to handle different 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