Instruction switch en langage Go
Instruction conditionnelle du langage Go
L'instruction switch est utilisée pour exécuter différentes actions en fonction de différentes conditions. Chaque branche case est unique et est testée une par une du haut vers le bas jusqu'à ce qu'une correspondance soit trouvée.
L'instruction switch s'exécute du haut vers le bas jusqu'à ce qu'une correspondance soit trouvée, et il n'est pas nécessaire d'ajouter un break après la branche case correspondante.
Par défaut, chaque branche case dans switch comporte une instruction break à la fin, donc après une correspondance réussie, les autres branches case ne seront pas exécutées. Si nous devons exécuter les branches case suivantes, nous pouvons utiliserfallthrough 。
Syntaxe
La syntaxe de l'instruction switch dans le langage de programmation Go est la suivante :
switch var1 {
case val1:
...
case val2:
...
default:
...
}
La variable var1 peut être de n'importe quel type, tandis que val1 et val2 peuvent être n'importe quelles valeurs du même type. Le type n'est pas limité aux constantes ou aux entiers, mais doit être du même type ; ou des expressions dont le résultat final est du même type.
Vous pouvez tester plusieurs valeurs susceptibles de correspondre en même temps, en les séparant par des virgules, par exemple : case val1, val2, val3.
Organigramme :
Exemple
import "fmt"
func main() {
/* Définir les variables locales */
var grade string = "B"
var marks int = 90
switch marks {
case 90: grade = "A"
case 80: grade = "B"
case 50,60,70 : grade = "C"
default: grade = "D"
}
switch {
case grade == "A" :
fmt.Printf("Excellent !\n" )
case grade == "B", grade == "C" :
fmt.Printf("Bien\n" )
case grade == "D" :
fmt.Printf("Passable\n" )
case grade == "F":
fmt.Printf("Échec\n" )
default:
fmt.Printf("Faible\n" );
}
fmt.Printf("Votre note est %s\n", grade );
}
Le résultat d'exécution du code ci-dessus est :
优秀! 你的等级是 A
Switch de type
L'instruction switch peut également être utilisée pour un type-switch afin de déterminer le type réel stocké dans une variable d'interface.
Le format de syntaxe de Type Switch est le suivant :
switch x.(type){
case type:
statement(s);
case type:
statement(s);
/* 你可以定义任意个数的case */
default: /* 可选 */
statement(s);
}
Exemple
import "fmt"
func main() {
var x interface{}
switch i := x.(type) {
case nil:
fmt.Printf(" Le type de x est %T",i)
case int:
fmt.Printf("x est de type int")
case float64:
fmt.Printf("x est de type float64")
case func(int) float64:
fmt.Printf("x est de type func(int)")
case bool, string:
fmt.Printf("x est de type bool ou string" )
default:
fmt.Printf("Type inconnu")
}
}
Le résultat d'exécution du code ci-dessus est :
x 的类型 :<nil>
fallthrough
L'utilisation de fallthrough force l'exécution de l'instruction case suivante ; fallthrough n'évalue pas si le résultat de l'expression du case suivant est vrai.
Exemple
import "fmt"
func main() {
switch {
case false:
fmt.Println("1. L'instruction conditionnelle case est fausse")
fallthrough
case true:
fmt.Println("2. L'instruction conditionnelle case est vraie")
fallthrough
case false:
fmt.Println(3. La condition du case est fausse)
fallthrough
case true:
fmt.Println(4. La condition du case est vraie)
case false:
fmt.Println(5. La condition du case est fausse)
fallthrough
default:
fmt.Println(6. Cas par défaut)
}
}
Le résultat d'exécution du code ci-dessus est :
2、case 条件语句为 true 3、case 条件语句为 false 4、case 条件语句为 true
D'après la sortie du code ci-dessus, on peut voir que switch commence à s'exécuter à partir du premier case dont l'expression d'évaluation est vraie. Si le case a un fallthrough, le programme continuera d'exécuter le case suivant, et il n'évaluera pas si l'expression du case suivant est vraie.
autres extensions