Go Academy · Leçon

Instructions switch en Go

switch avec ou sans étiquette, et fallthrough

Leçon 3 sur 412 étapes

Instructions switch en Go est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Bases de switch

Le switch de Go est plus puissant que celui de C : aucun passage automatique au cas suivant et plusieurs valeurs sont possibles dans un même cas :

day := "Monday"
switch day {
case "Saturday", "Sunday":
    fmt.Println("Weekend")
default:
    fmt.Println("Weekday")
}

Pas de passage implicite au cas suivant

Dans Go, le bloc de chaque case se termine automatiquement, contrairement à C où vous devez écrire explicitement break :

  • Un code plus clair et moins d’erreurs
  • Utilisez explicitement fallthrough lorsque vous avez besoin d’un comportement similaire à celui de C, ce qui est rare

switch avec une instruction d’initialisation

Comme if, switch accepte une instruction d’initialisation facultative :

switch os := runtime.GOOS; os {
case "linux":
    fmt.Println("Linux")
case "darwin":
    fmt.Println("macOS")
default:
    fmt.Printf("Other: %s\n", os)
}

switch sans expression (alternative à la chaîne if-else)

Un switch sans expression ne comporte aucune expression après le mot-clé : chaque case évalue une valeur booléenne :

score := 75
switch {
case score >= 90:
    fmt.Println("A")
case score >= 80:
    fmt.Println("B")
case score >= 70:
    fmt.Println("C")
default:
    fmt.Println("F")
}

Switch sur les types

Un switch sur les types examine le type dynamique d’une valeur d’interface :

func describe(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("int: %d\n", v)
    case string:
        fmt.Printf("string: %s\n", v)
    default:
        fmt.Printf("unknown: %T\n", v)
    }
}

fallthrough

Utilisez fallthrough pour exécuter explicitement le bloc du cas suivant, quelle que soit sa condition, ce qui est rarement nécessaire :

n := 1
switch n {
case 1:
    fmt.Println("one")
    fallthrough
case 2:
    fmt.Println("one or two")
}

Plusieurs valeurs par cas

Énumérez plusieurs valeurs séparées par des virgules dans un seul cas :

func isVowel(c byte) bool {
    switch c {
    case 'a', 'e', 'i', 'o', 'u':
        return true
    }
    return false
}

switch ou if-else

Utilisez switch lorsque :

  • Vous comparez une expression à de nombreuses valeurs
  • Vous utilisez un switch sur les types pour la sélection selon l’interface
  • La lisibilité est meilleure qu’avec une chaîne de if-else

Utilisez if-else lorsque les conditions sont des expressions booléennes différentes.

break dans switch

Pour quitter un switch prématurément, utilisez break. Pour quitter une boucle externe depuis un switch, utilisez un break étiqueté :

loop:
for {
    switch input() {
    case "quit":
        break loop  // exits the for loop
    }
}

Cas par défaut

Le cas default s’exécute lorsqu’aucun autre cas ne correspond. Bonnes pratiques :

  • Incluez toujours default lors du traitement d’énumérations, afin de détecter les valeurs inattendues
  • Placez-le à la fin pour améliorer la lisibilité
  • Dans les switch sur les types, utilisez default pour gérer correctement les types non pris en charge

Vérification rapide

Que se passe-t-il dans Go lorsqu’un cas de switch correspond : l’exécution passe-t-elle au cas suivant ?

Récapitulatif : switch dans Go

Le switch de Go est clair et puissant :

  • Aucun passage implicite au cas suivant : utilisez explicitement fallthrough
  • Instruction d’initialisation pour limiter la portée des variables temporaires
  • Switch sans expression comme alternative à une chaîne if-else
  • Switch sur les types pour la sélection selon l’interface
  • Plusieurs valeurs par cas, séparées par des virgules

Suite : contrôle des boucles avec break, continue et les étiquettes.

Gratuit pour commencer

Apprends Go avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
51
Leçons
203

Questions Fréquemment Posées

La leçon « Instructions switch en Go » est-elle gratuite ?

Oui — le texte complet de « Instructions switch en Go » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Instructions switch en Go » ?

switch avec ou sans étiquette, et fallthrough Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Instructions switch en Go » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Instructions if et expressions d’initialisation
  2. La boucle for : tous les modèles
  3. Instructions switch en Go
  4. break, continue et étiquettes
← Retour à Go Academy