Golang est un langage de programmation efficace et moderne qui offre de riches fonctionnalités en matière de contrôle de processus. Cet article explorera les structures de contrôle de flux dans Golang, y compris les instructions conditionnelles, les instructions de boucle et les instructions de saut, pour aider les lecteurs à mieux comprendre et appliquer ces structures.
Déclarations conditionnelles
Les déclarations conditionnelles dans Golang incluent les instructions if, les instructions switch et les instructions select.
if l'instruction est utilisée pour formuler des jugements conditionnels La syntaxe est la suivante :
if condition {
statement(s)
} else if condition {
statement(s)
} else {
statement(s)
}où condition est une expression conditionnelle utilisée pour juger vrai ou faux. Si la condition est vraie, le bloc d'instructions suivant if est exécuté ; sinon, le bloc d'instructions est ignoré et l'instruction suivante est exécutée.
Si la condition est suivie du mot-clé else if, chaque expression conditionnelle sera évaluée dans l'ordre et le premier bloc d'instructions vrai sera exécuté. Si toutes les expressions conditionnelles sont fausses, le bloc d'instructions suivant le else est exécuté. Sans le bloc else, aucune instruction n'est exécutée si la condition est fausse.
Ce qui suit est un exemple d'instruction if :
package main
import "fmt"
func main() {
var a int = 10
if a < 20 {
fmt.Printf("a 小于 20
")
}
fmt.Printf("a 的值为 : %d
", a)
}Résultat de sortie :
a 小于 20 a 的值为 : 10
l'instruction switch est utilisée pour le jugement multi-conditions, la syntaxe est la suivante :
switch expression {
case value1:
statement(s)
case value2:
statement(s)
case value3:
statement(s)
default:
statement(s)
}Où, l'expression est une expression, utilisée pour faire correspondre une constante ou une variable dans une clause case. Si la correspondance réussit, le bloc d'instructions correspondant est exécuté ; sinon, le bloc d'instructions est ignoré et la clause case suivante (si elle existe) est exécutée.
Si toutes les clauses case ne correspondent pas correctement, le bloc d'instructions suivant la valeur par défaut sera exécuté. S'il n'y a pas de clause par défaut, aucune instruction n'est exécutée.
Ce qui suit est un exemple d'instruction switch :
package main
import "fmt"
func main() {
var grade string = "B"
var marks int = 90
switch marks {
case 90:
grade = "A"
case 80:
grade = "B"
case 60, 70:
grade = "C"
default:
grade = "D"
}
switch {
case grade == "A" :
fmt.Printf("优秀!
" )
case grade == "B", grade == "C" :
fmt.Printf("良好
" )
case grade == "D" :
fmt.Printf("及格
" )
case grade == "F":
fmt.Printf("不及格
" )
default:
fmt.Printf("差
" )
}
fmt.Printf("你的等级是 %s
", grade )
}Résultat de sortie :
良好! 你的等级是 B
l'instruction select est utilisée pour surveiller plusieurs canaux en même temps La syntaxe est la suivante :
select {
case communication clause 1:
statement(s)
case communication clause 2:
statement(s)
.............
default:
statement(s)
}Among. Pour eux, la clause de communication fait référence à un canal ou à une opération de canal avec direction, y compris l'opération d'envoi et l'opération de réception. Si un canal contient des données qui peuvent être lues ou écrites, le bloc d'instructions correspondant est exécuté ; sinon, le canal est ignoré et la clause de communication suivante est exécutée ; Si aucune donnée n'est lisible ou inscriptible sur aucun canal, le bloc d'instruction suivant la valeur par défaut est exécuté.
Ce qui suit est un exemple d'instruction select :
package main
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 0, 1
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)
}Résultat de sortie :
0 1 1 2 3 5 8 13 21 34 quit
Instruction de boucle
Les instructions de boucle dans Golang incluent des instructions for et des instructions range.
l'instruction for est utilisée pour exécuter un morceau de code dans une boucle. La syntaxe est la suivante :
for init; condition; post {
statement(s);
}Parmi eux, init est utilisé pour démarrer la boucle, la condition est utilisée pour déterminer si la boucle. continue et post est utilisé pour contrôler le fonctionnement des variables de boucle.
Ce qui suit est un exemple d'instruction for :
package main
import "fmt"
func main() {
var b int = 15
var a int
for i := 0; i < 10; i++ {
fmt.Printf("i 的值为: %d
", i)
}
for a < b {
a++
fmt.Printf("a 的值为: %d
", a)
}
}Résultat de sortie :
i 的值为: 0 i 的值为: 1 i 的值为: 2 i 的值为: 3 i 的值为: 4 i 的值为: 5 i 的值为: 6 i 的值为: 7 i 的值为: 8 i 的值为: 9 a 的值为: 1 a 的值为: 2 a 的值为: 3 a 的值为: 4 a 的值为: 5 a 的值为: 6 a 的值为: 7 a 的值为: 8 a 的值为: 9 a 的值为: 10 a 的值为: 11 a 的值为: 12 a 的值为: 13 a 的值为: 14 a 的值为: 15
L'instruction range est utilisée pour parcourir les éléments d'un tableau, d'une tranche, d'un canal ou d'une carte. La syntaxe est la suivante. comme suit :
for key, value := range oldMap {
newMap[key] = value
}où, key et value représentent respectivement la clé et la valeur de l'élément actuel.
Ce qui suit est un exemple d'instruction de plage :
package main
import "fmt"
func main() {
nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
sum += num
}
fmt.Println("sum:", sum)
for i, num := range nums {
if num == 3 {
fmt.Println("index:", i)
}
}
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
fmt.Printf("%s -> %s
", k, v)
}
}Résultat de sortie :
sum: 9 index: 1 a -> apple b -> banana
Instruction Jump
Les instructions Jump en Golang incluent break, continue et goto.
instruction break est utilisée pour interrompre le corps de la boucle, la syntaxe est la suivante :
for i := 0; i < 10; i++ {
if i == 5 {
break
}
fmt.Printf("%d ", i)
}
fmt.Println()Résultat de sortie :
0 1 2 3 4
instruction continue est utilisée pour interrompre cette itération du courant corps de la boucle, la syntaxe est la suivante :
for i := 0; i < 10; i++ {
if i == 5 {
continue
}
fmt.Printf("%d ", i)
}
fmt.Println()Résultat de sortie :
0 1 2 3 4 6 7 8 9
l'instruction goto est utilisée pour accéder sans condition à une certaine étiquette de code (étiquette) pour l'exécution. La syntaxe est la suivante :
goto label; ... label: statement
où l'étiquette est un identifiant et l'instruction est une instruction d'exécution.
Ce qui suit est un exemple d'instruction goto :
package main
import "fmt"
func main() {
i := 0
Again:
fmt.Printf("循环执行次数：%d
", i)
i++
if i < 10 {
goto Again
}
}Résultat de sortie :
循环执行次数：0 循环执行次数：1 循环执行次数：2 循环执行次数：3 循环执行次数：4 循环执行次数：5 循环执行次数：6 循环执行次数：7 循环执行次数：8 循环执行次数：9
Résumé
Les structures de contrôle de flux dans Golang incluent des instructions conditionnelles, des instructions de boucle et des instructions de saut. Les instructions conditionnelles incluent les instructions if, switch et select, qui sont utilisées pour effectuer des jugements sur une ou plusieurs conditions. Les instructions de boucle incluent les instructions for et range, qui sont utilisées pour parcourir un morceau de code ou parcourir un élément. Les instructions de saut incluent les instructions break, continue et goto, qui sont utilisées pour interrompre la boucle en cours ou accéder sans condition à une étiquette pour exécution. Dans la programmation réelle, il est nécessaire de sélectionner de manière flexible la structure de contrôle de processus appropriée en fonction des besoins de mise en œuvre de la logique du code.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
