Instructions conditionnelles Switch-Case en Golang

Introduction

Dans le laboratoire précédent, nous avons appris à utiliser les instructions conditionnelles if-else. Dans ce laboratoire, nous allons apprendre les instructions conditionnelles switch-case. Par rapport aux instructions if-else, les instructions switch sont plus adaptées aux scénarios avec de multiples conditions.

Points clés de connaissance :

• Instructions switch-case
• Mot clé default
• Mot clé fallthrough

Skills Graph

Basic Syntax

La syntaxe de l'instruction conditionnelle switch est similaire à celle de l'instruction conditionnelle if, car elles ont toutes deux des évaluations conditionnelles. La syntaxe de base est la suivante :

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

La condition peut être une expression de n'importe quel type. Lorsque la condition correspond à la valeur d'une certaine instruction case, l'instruction case correspondante sera exécutée, puis le programme sortira de la branche switch actuelle.

Les valeurs dans les instructions case doivent être du même type que l'expression de la condition.

Le programme évaluera les instructions case de haut en bas et exécutera la première instruction case qui correspond. Une fois l'exécution terminée, il sortira de la branche switch actuelle.

L'instruction default est similaire à l'instruction else. Lorsqu'aucune autre instruction case ne correspond à la condition, l'instruction default sera exécutée.

Regardons un exemple de prévision météorologique. Créez un nouveau fichier nommé switch.go et écrivez le code suivant :

cd ~/project
touch switch.go

package main

import (
    "fmt"
)

func main() {
    // Today's weather
    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

La sortie est la suivante :

Remember to bring an umbrella today.🌂

Cette prévision météorologique affichera différents résultats en fonction des conditions météorologiques. Tout d'abord, nous avons défini la météo d'aujourd'hui comme "rainy" (pluvieux). Dans la branche switch-case ci-dessous, nous avons défini trois conditions différentes. Lorsqu'il neige, nous vous rappelons de porter une écharpe, lorsqu'il pleut, nous vous rappelons d'apporter un parapluie, et sinon, nous considérons que c'est une journée ensoleillée.

Multiple Values in a Branch

L'instruction case peut également avoir plusieurs valeurs, comme indiqué ci-dessous :

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

Nous avons mis à jour le programme météo comme suit :

package main

import (
    "fmt"
)

func main() {
    // Today's weather
    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 avoir exécuté le code, la sortie est la suivante :

Remember to wear a scarf today.🧣

Nous avons ajouté quelques conditions météorologiques. Nous devons porter un masque lorsqu'il y a de la brume ou une tempête de sable.

switch Statements with No Conditional Variable

La variable conditionnelle dans l'instruction switch est un paramètre facultatif. Lorsque la variable conditionnelle est omise, l'instruction switch se comportera de manière similaire à une instruction if-else.

Nous avons réécrit le programme pour afficher le jour de la semaine d'aujourd'hui de la section précédente en utilisant l'instruction switch sans variable conditionnelle :

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 avoir exécuté le code, la sortie est la suivante :

Today is Monday.

Dans ce programme, la variable conditionnelle a été supprimée de l'instruction switch. Lorsque le programme est exécuté, il vérifiera si les conditions dans chaque branche case sont remplies. Lorsqu'une condition case est satisfaite, le code de cette branche sera exécuté, et enfin, le programme sortira du bloc switch.

fallthrough Statement

Comme mentionné précédemment, après qu'un programme a exécuté une branche case, il sort de la branche switch actuelle.

Si vous souhaitez continuer à exécuter la branche suivante après avoir exécuté une branche case, vous pouvez utiliser l'instruction fallthrough.

Voici les spécifications pour utiliser l'instruction fallthrough :

• Par défaut, après que l'instruction switch a trouvé une correspondance et exécuté case 10, elle n'exécutera pas les branches suivantes. L'instruction fallthrough exécutera les branches case suivantes.
• fallthrough n'affecte que l'instruction case suivante et ne vérifie pas la condition du case.
• fallthrough ne peut pas être utilisé dans la dernière branche d'un switch.

Voyons un exemple concret :

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 avoir exécuté le code, la sortie est la suivante :

10
3

La branche switch affiche 10 après que l'instruction case 10 a été trouvée en correspondance, puis elle affiche l'instruction case suivante du fallthrough.

Initialization Statement in switch

En Go, non seulement les instructions conditionnelles if ont des instructions d'initialisation, mais les instructions conditionnelles switch en ont également. Vous pouvez écrire l'instruction d'initialisation avant la variable conditionnelle, séparée par un point-virgule.

Quiz

Maintenant, vous allez réécrire le programme de la section précédente et déplacer l'instruction d'initialisation dans l'instruction switch.

Créez un nouveau fichier nommé switch2.go. Écrivez le code suivant dans le fichier switch2.go. Modifiez le programme de la section précédente et déplacez l'instruction d'initialisation dans l'instruction switch.

cd ~/project
touch switch2.go

Le code de la section précédente est le suivant :

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.

Indice : Vous pouvez vous référer à la section sur le programme d'initialisation dans le laboratoire (lab) if-else pour effectuer la modification.

Summary

Dans ce laboratoire (lab), nous avons expliqué l'instruction conditionnelle switch. Les points clés sont les suivants :

• Lorsque l'instruction case trouve une correspondance et est exécutée, elle sort du bloc switch actuel.
• Vous pouvez utiliser fallthrough pour continuer à exécuter l'instruction case suivante.
• switch a également une instruction d'initialisation, séparée de l'expression conditionnelle par un point-virgule.