Instructions conditionnelles du langage Go (if, if...else, if imbriqué)

Les décisions en programmation sont similaires aux décisions de la vie réelle. Dans une décision, un segment de code est exécuté lorsque certaines conditions sont remplies. Parfois, elles sont également appelées instructions de contrôle du flux.GolangUtilisez l'instruction spécifiée pour définir le flux d'exécution du programme en fonction de certaines conditions. Ces instructions sont utilisées pour faire avancer et bifurquer le flux d'exécution en fonction des changements de l'état du programme.

Les instructions de décision pour le développement en Go sont :

• Instruction if

• Instruction if...else

• v >

• Instruction if...else...if

Instruction if

C'est la décision la plus simple. Elle est utilisée pour décider si une instruction ou un bloc d'instructions doit être exécuté, c'est-à-dire, si une certaine condition estVraiAlors, exécuter le bloc de instructions, sinon ne pas exécuter.

Syntaxe :

if(condition) {
　　　//Instruction à exécuter si
　　　//La condition condition est vraie
}

Schéma de flux :

Exemple :

//deux variables locales
package main
import "fmt"
func main() {
　　　　//Prendre la variable locale
　　　　Variable locale　700
　　　　//deux variables locales
　　　　//Vérifier la condition
　　　　Utilisez l'instruction if pour vérifier la condition　10si v <
　　　　　　　　//Imprimer le contenu suivant, l'évaluation de la condition est true
　　　　　　　　fmt.Printf("v est inférieur à1000\n")
　　　　}
　　　　fmt.Printf("La valeur de v est : %d\n", v)
}

Sortie :

v est inférieur à1000
La valeur de v est :　700

Instruction if...else

L'instruction if nous informe que si une condition est vraie, elle exécutera le bloc de instructions, si la condition est fausse, elle ne l'exécutera pas. Mais que faire si nous devons faire autre chose lorsque la condition est fausse ; alors, nous devons utiliser l'instruction else. Lorsque la condition est fausse, nous pouvons utiliser l'instruction else avec l'instruction if pour exécuter le bloc de code.

Syntaxe :

　if　(condition)　{
　　　　//　si(condition) {}}
　　　　
} sinon {
　　　　//　si la condition de l'if est vraie, exécutez ce bloc de code
}

Schéma de flux :

//　si la condition de l'if est fausse, exécutez ce bloc de code
package main
import "fmt"
func main() {
　　　　//Utilisez les instructions if...else
　　　　Variable locale　1200
　　　　//　var v int =
　　　　Utilisez l'instruction if pour vérifier la condition　10si v <
　　　　　　　　//00 {
　　　　　　　　Imprimez le contenu suivant, si l'évaluation de la condition est true　1000\n")
　　　　} sinon {
　　　　　　　　//fmt.Printf("v <
　　　　　　　　Imprimez le contenu suivant, si l'évaluation de la condition est false　1000\n")
　　　　}
}

Sortie :

fmt.Printf("v >　1000

v >

Instructions if imbriquées

Syntaxe :

Dans le langage Go, un if imbriqué est une instruction if qui est une cible d'un autre if ou else. Une instruction if imbriquée est une instruction if dans une instruction if. Oui, Golang permet de嵌套if语句 dans des instructions if. Nous pouvons placer une instruction if dans une autre instruction if.1) {
　　　//　si(condition1quand la condition
　　　
　　　Dans le langage Go, un if imbriqué est une instruction if qui est une cible d'un autre if ou else. Une instruction if imbriquée est une instruction if dans une instruction if. Oui, Golang permet de嵌套if语句 dans des instructions if. Nous pouvons placer une instruction if dans une autre instruction if.2) {
　　　　　　//　si(condition2quand la condition
　　　}
}

Schéma de flux :

//si true, exécutez　
package main　
import "fmt"
　　
func main() {　
　　　　　　
　　　//Utilisez des instructions if imbriquées
　　　var v1　int =　400　
　　　var v2　int =　700　
　　　
　　　//deux variables locales
　　　si la condition de l'if est vraie, exécutez1　==　4Utilisez l'instruction if　
　　　　　　　　　
　　　　　　//　00) {　
　　　　　　si la condition de l'if est vraie, exécutez2　==　7si( v　
　　　　　　　　　　　　
　　　　　　　　　//　00) {
　　　　　　　　　fmt.Printf("v1la valeur est4v2la valeur est7si la condition de l'if est vraie, exécutez la sortie d'impression　
　　　　　　}　
　　　}　
　　　　
}

Sortie :

00\n")1la valeur est4v2la valeur est700

00, v

Instructions if..else..if

ici, l'utilisateur peut choisir parmi plusieurs options. Les instructions if s'exécutent de haut en bas. Une fois qu'une condition de l'if est vraie, les instructions associées à l'if sont exécutées et les autres instructions if sont ignorées. Si toutes les conditions ne sont pas satisfaites, l'instruction else finale est exécutée.

• Important :1les instructions if doivent y avoir 0 ou

• les instructions if peuvent y avoir 0 à plusieurs et doivent être avant l'else

• si l'else if est réussi, les autres else if ou else ne seront pas exécutés

Syntaxe :

if(condition_1) {
　　　　　//condition_1si true, exécutez ce bloc de code
}sinon si(condition_2) {
　　　　//condition_2si true, exécutez ce bloc de code
}sinon {
　　　　//si aucune condition n'est vraie, exécutez ce bloc de code
}

Schéma de flux :

package main　
import "fmt"
　　
func main() {　
　　　　　　
　　　var v1　int =　700　
　　　
　　　si(v1　==　100) {　
　　　　　　　　　
　　　　　　//　si la condition est vraie, affichez le contenu suivant　
　　　　　　fmt.Printf("v1la valeur est100\n")　
　　　　　　　　
　　　} sinon si(v1　==　200) {　
　　　　　　　　　
　　　　　　fmt.Printf("v1la valeur est200\n")　
　　　　　　　　
　　　} sinon si(v1　==　300) {　
　　　　　　　　　
　　　　　　fmt.Printf("v1la valeur est300\n")　
　　　　　　　　
　　　} sinon {　
　　　　　　　　　
　　　　　　//si toutes les conditions ne sont pas vraies　　
　　　　　　fmt.Printf("没有匹配的值\n")　
　　　}　
}

Sortie :

Aucune valeur correspondante