Instructions Switch du langage Go

Le statement switch est une instruction de branche multiple. Il offre une méthode efficace pour transférer l'exécution vers différentes parties du code en fonction de la valeur de l'expression (également appelée case). Le langage Go supporte deux types de statements switch:

1. L'expression switch

2. switch sur le type

L'expression switch

L'expression switch est similaire à C, C ++，l'instruction switch dans le langage Java. Elle offre une méthode simple pour acheminer l'exécution vers différentes parties du code en fonction de la valeur de l'expression.

Syntaxe :

switch optstatement; optexpression{
　　　　case expression1: Statement..
　　　　case expression2: Statement..
　　　　...
　　　　default: Statement..
}

Remarque importante :

• Les instructions optstatement et optexpression dans l'expression switch sont des instructions optionnelles.

• Si elles existent en même tempsoptstatementetoptpression，il faut utiliser le point-virgule (;) entre elles.

• Si l'instruction switch ne contient aucune expression, le compilateur suppose que cette expression est true.

• L'instruction optionnelle, c'est-à-dire optstatement, contient des instructions simples, telles que les déclarations de variables, les instructions d'incrémentation ou d'affectation ou les appels de fonctions, etc.

• Si une expression optionnelle contient une variable, la portée de cette variable est limitée à l'instruction switch.

• Dans l'instruction switch, les instructions case et default ne contiennent pas d'instruction break. Mais si votre programme le nécessite, vous pouvez utiliser les instructions break et fallthrough.

• L'instruction par défaut (default) dans l'instruction switch est optionnelle.

• Si un case peut contenir plusieurs valeurs, et ces valeurs sont séparées par des virgules (,).

• Si un case ne contient aucune expression, le compilateur suppose que cette expression est true.

Exemple de récupération de la journée spécifique de la semaine :

package main
import "fmt"
func main() {
　　　　//　L'instruction switch utilise deux types d'instructions, par exemple, l'instruction optionnelle, day :=4　et l'expression, par exemple : day
　　　　switch day :=　4; day {
　　　　case　1:
　　　　　　　　fmt.Println("Lundi")
　　　　case　2:
　　　　　　　　fmt.Println("Mardi")
　　　　case　3:
　　　　　　　　fmt.Println("Mercredi")
　　　　case　4:
　　　　　　　　fmt.Println("Jeudi")
　　　　case　5:
　　　　　　　　fmt.Println("Vendredi")
　　　　case　6:
　　　　　　　　fmt.Println("Samedi")
　　　　case　7:
　　　　　　　　fmt.Println("Dimanche")
　　　　défaut :
　　　　　　　　fmt.Println("Invalid")
　　　　}
}

Sortie :

Jeudi

Exemple d'instruction switch sans expression optionnelle et expression :

package main　
　　
import "fmt"
　　
func main() {　
　　　　var value int =　2　
　　　　　　
　　　　　　//　L'instruction switch sans expression optionnelle et expression
　　　switch {　
　　　　　　　case value ==　1:　
　　　　　　　fmt.Println("Hello")　
　　　　　　　case value ==　2:　
　　　　　　　fmt.Println("Bonjour")　
　　　　　　　case value ==　3:　
　　　　　　　fmt.Println("Namstay")　
　　　　　　　défaut :　　
　　　　　　　fmt.Println("Invalid")　
　　　}　
　　
}

Sortie :

Bonjour

Voici une instruction switch sans expression par défaut, plusieurs valeurs dans l'instruction case :

package main
import "fmt"
func main() {
　　　　var value string = "five"
　　　　//Instruction switch sans clause par défaut, plusieurs valeurs dans les clauses case
　　　　switch value {
　　　　case "one":
　　　　　　　　fmt.Println("C#")
　　　　case "two", "three":
　　　　　　　　fmt.Println("Go")
　　　　case "four", "five", "six":
　　　　　　　　fmt.Println("Java")
　　　　}
}

Sortie :

Java

switch sur le type

Lorsque vous voulez comparer des types, utilisez le switch sur le type. Dans ce switch, les clauses case contiennent les types à comparer avec ceux de l'expression switch.

Syntaxe :

switch optstatement; typeswitchexpression{
　　　　case typelist　1: Statement..
　　　　case typelist　2: Statement..
　　　　...
　　　　default: Statement..
}

Remarque importante :

• Clause optionnelle, c'est-à-dire optstatement, similaire à celle de l'expression switch.

• Si un case peut contenir plusieurs valeurs, et ces valeurs sont séparées par des virgules (,).

• Dans une instruction switch sur le type, les clauses case et default ne contiennent pas de statement break. Cependant, si nécessaire, les statements break et fallthrough peuvent être utilisées.

• Dans une instruction switch sur le type, la clause par défaut est optionnelle.

• expression_typeswitchest une expression qui renvoie un type.

• Si une expression est assignée avec l'opérateur = dans une expression typeswitch, le type de la variable dépend du type de la clause case. Si la clause case contient deux types ou plus, le type de la variable est le type créé lors de la création de l'expression dans l'expression typeswitch.

package main
import "fmt"
func main() {
　　　　var value interface{}
　　　　switch q := value.(type) {
　　　　case bool :
　　　　　　　　fmt.Println("La valeur est de type bool")
　　　　case float64:
　　　　　　　　fmt.Println("La valeur est float")64type)
　　　　case int :
　　　　　　　　fmt.Println("La valeur est de type int")
　　　　défaut :
　　　　　　　　fmt.Printf("Le type de la valeur est: %T", q)
　　　　}
}

Sortie :

Le type de la valeur est: <nil>