déclaration conditionnelle langue Go
déclaration conditionnelle requise par les développeurs de spécifier une ou plusieurs conditions, et s'il est vrai de décider d'exécuter les conditions d'essai spécifiées par l'instruction, et si la condition est fausse dans la mise en œuvre d'autres déclarations.
La figure ci-dessous montre la structure de la langue du programme instruction conditionnelle:
| déclaration | description |
|---|---|
| L'instruction if | si la déclaration est suivie d'une expression booléenne par celle - ci ou plusieurs déclarations. |
| if ... autre | instruction if après peut utiliser l'option instruction else , instruction else dans l'expression d'exécution est faux dans les expressions booléennes. |
| si les déclarations imbriquées | Vous pouvez si ou bien si intégré dans une ou plusieurs déclarations si ou d' autre si la déclaration. |
| instruction switch | interrupteur instruction est utilisé pour effectuer différentes actions en fonction des conditions différentes. |
| instruction select | sélectionnez déclaration similaire à l' interrupteur déclaration, mais le cas d'exécution sélectionnera au hasard une course. S'il n'y a aucun cas courir, il bloque jusqu'à ce que le cas a été exécuté. |
si, si ... autre déclaration et python ou C comme langue
Clé pour expliquer:
instruction switch en fonction des conditions différentes pour effectuer des actions différentes, chaque branche de cas est unique, testé individuellement de haut en bas, jusqu'à ce que le match.
instruction Switch exécute le processus de haut en bas, jusqu'à ce qu'une correspondance est trouvée, suivie d'un match n'a pas besoin d'ajouter pause.
interrupteur cas par défaut la dernière instruction break est dans le cas, après un match réussi ne fonctionne pas d' autres cas, si nous devons faire derrière le cas, vous pouvez utiliser fallthrough .
grammaire
syntaxe de l'instruction de commutation de langage de programmation Go est la suivante:
switch var1 {
case val1:
...
case val2:
...
default:
...
}
Il peut être tout type de var1, alors que val1 val2 et peut-être une valeur du même type. Ou le type ne se limite pas à un nombre entier constant, mais doit être du même type, ou le résultat final est le même type d'expression.
Vous pouvez tester simultanément plusieurs valeurs peuvent répondre aux critères, ils sont séparés par des virgules, par exemple: cas val1, val2, val3.
Flowchart:
func tyepe() {
// switch语句练习
grader := "B"
marks := 40
switch marks {
case 90:
grader = "A"
case 80:
grader = "B"
case 50, 60, 70:
grader = "C"
default:
grader = "D"
}
switch {
case grader == "A":
fmt.Println("优秀")
case grader == "B":
fmt.Println("良好")
case grader == "C":
fmt.Println("及格")
case grader == "D":
fmt.Println("不及格")
}
}
func main() {
// traversalstring()
// changeStrings()
tyepe()
}
Type Commutateur
instruction switch peut également être utilisé pour déterminer le type commutateur l'interface d'une variable de type variable effectivement stockée.
Type syntaxe de commutation est la suivante:
switch x.(type){
case type:
statement(s);
case type:
statement(s);
/* 你可以定义任意个数的case */
default: /* 可选 */
statement(s);
}
func test() {
var x interface{}
switch i := x.(type) {
case nil:
fmt.Println("x的类型是 %T", i)
case int:
fmt.Println("x的类型是 %T", i)
case float32:
fmt.Println("x的类型是 %T", i)
case bool, string:
fmt.Println("x的类型是 %T", i)
default:
fmt.Println("未知类型")
}
}
func main() {
// traversalstring()
// changeStrings()
// tyepe()
test()
}
Les résultats d'exécution de code ci-dessus:
x 的类型 :<nil>
tomber dans
Utilisez Enforces fallthrough le dos de la déclaration de cas, une affaire en ne juge fallthrough si le résultat de l'expression est vraie.
package main
import "fmt"
func main() {
switch {
case false:
fmt.Println("1、case 条件语句为 false")
fallthrough
case true:
fmt.Println("2、case 条件语句为 true")
fallthrough
case false:
fmt.Println("3、case 条件语句为 false")
fallthrough
case true:
fmt.Println("4、case 条件语句为 true")
case false:
fmt.Println("5、case 条件语句为 false")
fallthrough
default:
fmt.Println("6、默认 case")
}
}
Les résultats d'exécution de code ci-dessus:
2、case 条件语句为 true
3、case 条件语句为 false
4、case 条件语句为 true
A partir des résultats ci-dessus sortie de code: commutateur commence à la première expression est une détermination de l'affaire vrai, un cas continuera à fonctionner si le cas a fallthrough, programme, et il est de ne pas juger l'expression suivante de cas si la formule est vraie.
instruction select
Go est une structure de commande de sélection est similaire à l'instruction de commutation pour la communication. Chaque cas doit être une opération de communication, soit la transmission ou de réception.
effectuée sélectionner au hasard un cas en cours d'exécution. S'il n'y a aucun cas courir, il bloque jusqu'à ce que le cas a été exécuté. Une clause par défaut doit toujours être exécuté.
syntaxe:
langage de programmation Go sélectionnez syntaxe de l'instruction est la suivante:
select {
case communication clause :
statement(s);
case communication clause :
statement(s);
/* 你可以定义任意数量的 case */
default : /* 可选 */
statement(s);
}
Ce qui suit décrit la syntaxe de l'instruction select:
-
Chaque cas doit être une communication
-
Toute expression de canal sera évalué
-
Toutes les expressions seront envoyés à évaluer
-
Si quelqu'un de la communication peut être effectuée, il effectue, l'autre est ignorée.
-
Si plus d'un cas peut exécuter, Select sélectionnera au hasard une exécution équitable. D'autres ne seront pas exécutées.
Dans le cas contraire:
- S'il y a la clause par défaut, l'instruction est exécutée.
- S'il n'y a pas de clause par défaut, sélectionnez le bloc jusqu'à ce qu'une communication peut fonctionner; aller au canal ou non re-valeur est évaluée.
Exemples
démos d'application instruction select:
package main
import "fmt"
func main() {
var c1, c2, c3 chan int
var i1, i2 int
select {
case i1 = <-c1:
fmt.Printf("received ", i1, " from c1\n")
case c2 <- i2:
fmt.Printf("sent ", i2, " to c2\n")
case i3, ok := (<-c3): // same as: i3, ok := <-c3
if ok {
fmt.Printf("received ", i3, " from c3\n")
} else {
fmt.Printf("c3 is closed\n")
}
default:
fmt.Printf("no communication\n")
}
}