Les structures de branchement Switch-Case en Golang

Introduction

Dans le lab précédent, nous avons étudié l'utilisation des structures de branchement if-else. Dans ce lab, nous allons découvrir les instructions switch-case. Par rapport aux instructions if-else, le switch est bien plus adapté lorsqu'il s'agit de gérer de multiples conditions.

Points de connaissances :

• Instructions switch-case
• Le mot-clé default
• Le mot-clé fallthrough

Syntaxe de base

La syntaxe de l'instruction de branchement switch est similaire à celle du if, car toutes deux reposent sur des évaluations conditionnelles. La syntaxe de base est la suivante :

switch condition {
    case val1:
        // bloc de code
    case val2:
        // bloc de code
    ...
    default:
        // bloc de code
}

La condition peut être n'importe quel type d'expression. Lorsque la condition correspond à la valeur d'une instruction case spécifique, le bloc de code associé est exécuté, puis le programme quitte la structure switch.

Les valeurs définies dans les instructions case doivent impérativement être du même type que l'expression de condition.

Le programme évalue les instructions case de haut en bas et exécute la première qui correspond. Une fois l'exécution terminée, il sort du bloc switch.

L'instruction default est analogue au else. Si aucune des valeurs case ne correspond à la condition, c'est le bloc default qui est exécuté.

Voyons un exemple concret avec une prévision météo. Créez un nouveau fichier nommé switch.go et écrivez le code suivant :

cd ~/project
touch switch.go

package main

import (
    "fmt"
)

func main() {
    // Météo du jour
    weather := "rainy"
    switch weather {
    case "snow":
        fmt.Println("Remember to wear a scarf today.🧣")
    case "rainy":
        fmt.Println("Remember to bring an umbrella today.🌂")
    default:
        fmt.Println("Today is sunny.☀")
    }
}

Exécutez le code :

go run switch.go

Le résultat est le suivant :

Remember to bring an umbrella today.🌂

Ce programme de météo affiche différents messages selon les conditions climatiques. Nous avons d'abord défini la météo sur "rainy" (pluvieux). Dans la structure switch-case, nous avons prévu trois cas : s'il neige, on conseille l'écharpe ; s'il pleut, le parapluie ; sinon, on considère qu'il fait beau.

Valeurs multiples dans une branche

Une instruction case peut également regrouper plusieurs valeurs, comme illustré ci-dessous :

switch condition {
    case val1, val2:
        // bloc de code
    ...
}

Mettons à jour notre programme météo de la manière suivante :

package main

import (
    "fmt"
)

func main() {
    // Météo du jour
    weather := "snow"
    switch weather {
    case "snow", "stormy":
        fmt.Println("Remember to wear a scarf today.🧣")
    case "haze", "sandstorm":
        fmt.Println("Remember to wear a mask today.😷")
    case "rainy":
        fmt.Println("Remember to bring an umbrella today.🌂")
    default:
        fmt.Println("Today is sunny.☀")
    }
}

go run switch.go

Après exécution, le résultat est :

Remember to wear a scarf today.🧣

Nous avons ajouté des conditions supplémentaires. Par exemple, le port du masque est conseillé en cas de brume (haze) ou de tempête de sable (sandstorm).

Instructions switch sans variable de condition

La variable de condition dans une instruction switch est un paramètre optionnel. Lorsqu'elle est omise, le switch se comporte de manière très similaire à une suite de if-else.

Réécrivons le programme qui affiche le jour de la semaine actuel en utilisant un switch sans variable de condition :

package main

import (
    "fmt"
    "time"
)

func main() {
    today := time.Now().Weekday()
    switch {
    case today == time.Monday:
        fmt.Println("Today is Monday.")
    case today == time.Tuesday:
        fmt.Println("Today is Tuesday.")
    case today == time.Wednesday:
        fmt.Println("Today is Wednesday.")
    case today == time.Thursday:
        fmt.Println("Today is Thursday.")
    case today == time.Friday:
        fmt.Println("Today is Friday.")
    case today == time.Saturday:
        fmt.Println("Today is Saturday.")
    default:
        fmt.Println("Today is Sunday.")
    }
}

go run switch.go

Après exécution, vous obtiendrez un résultat de ce type :

Today is Monday.

Dans ce programme, aucune variable n'est placée après le mot-clé switch. Lors de l'exécution, Go vérifie si les conditions de chaque branche case sont vraies (true). Dès qu'une condition est remplie, le code correspondant est exécuté, puis le programme quitte le bloc switch.

L'instruction fallthrough

Comme mentionné précédemment, après l'exécution d'une branche case, le programme sort normalement du switch.

Si vous souhaitez continuer l'exécution vers la branche suivante après avoir traité un case, vous devez utiliser l'instruction fallthrough.

Voici les règles d'utilisation de fallthrough :

• Par défaut, si le switch correspond au case 10, il s'arrête là. L'ajout de fallthrough force l'exécution de la branche suivante.
• fallthrough n'affecte que l'instruction case immédiatement suivante et ne vérifie pas la condition de ce case.
• fallthrough ne peut pas être utilisé dans la toute dernière branche d'un switch.

Voyons un exemple précis :

package main

import (
    "fmt"
)

func main() {
    n := 10
    switch n {
    case 10:
        fmt.Println(10)
        fallthrough
    case 3:
        fmt.Println(3)
    }
}

go run switch.go

Après exécution, le résultat est :

10
3

Le programme affiche 10 car case 10 correspond, puis, à cause du fallthrough, il exécute le code du case suivant et affiche 3.

Instruction d'initialisation dans le switch

En Go, les instructions de branchement switch disposent également d'une clause d'initialisation, tout comme le if. Vous pouvez écrire cette instruction avant la variable de condition, en les séparant par un point-virgule.

Quiz

À présent, vous allez réécrire le programme de la section précédente en déplaçant l'instruction d'initialisation directement dans l'instruction switch.

Créez un nouveau fichier nommé switch2.go. Écrivez le code dans ce fichier en modifiant la structure pour intégrer l'initialisation.

cd ~/project
touch switch2.go

Pour rappel, le code précédent était :

package main

import (
    "fmt"
)

func main() {
    n := 10
    switch n {
    case 10:
        fmt.Println(1)
        fallthrough
    case 3:
        fmt.Println(3)
    }
}

Exigences :

• Le fichier switch2.go doit être placé dans le répertoire ~/project.

Astuce : Vous pouvez vous référer à la section sur l'initialisation dans le lab if-else pour effectuer la modification.

Résumé

Dans ce lab, nous avons exploré l'instruction de branchement switch. Voici les points clés à retenir :

• Lorsqu'un case correspond et est exécuté, le programme quitte normalement le bloc switch.
• Le mot-clé fallthrough permet de forcer l'exécution de l'instruction case suivante.
• Le switch accepte une instruction d'initialisation, séparée de l'expression conditionnelle par un point-virgule.