Quelles sont les instructions de contrôle de flux Golang ?

Instruction de contrôle de flux : 1. instruction if, composée d'une expression booléenne suivie d'une ou plusieurs instructions ; 2. instruction "if...else", l'expression dans else est exécutée lorsque l'expression booléenne est fausse ; instruction switch, utilisée pour effectuer différentes actions en fonction de différentes conditions ; 4. instruction select ; 5. instruction de boucle for, syntaxe "for k,v := range oldmap{newmap[k]=v}" 6. instruction de contrôle de boucle break , continuez, allez-y.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Jetons un coup d'œil au contenu de base des instructions de contrôle de flux Golang.

1. L'instruction de branche conditionnelle

est similaire au langage C. Les instructions conditionnelles associées sont présentées dans le tableau suivant :

Statement	Description
if.	if l'instruction consiste en une expression booléenne suivie d'une ou plusieurs instructions.
instruction if…else	l'instruction if peut être suivie d'une instruction else facultative. L'expression dans l'instruction else est exécutée lorsque l'expression booléenne est fausse.
instruction switch	l'instruction switch est utilisée pour effectuer différentes actions en fonction de différentes conditions.
instruction select	L'instruction select est similaire à l'instruction switch, mais select exécutera aléatoirement un cas exécutable. S'il n'y a aucun cas à exécuter, il se bloquera jusqu'à ce qu'il y ait un cas à exécuter.

• instruction if
  La syntaxe est la suivante :

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}

• instruction if-else

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
	/* 在布尔表达式为 false 时执行 */
}

• instruction switch
  Les variables qu'elle contient<span class="hljs-attribute">v</span> peut être de n'importe quel type, val1 et val2 Il peut s'agir de n'importe quelle valeur du même type, le type n'est pas limité aux constantes ou aux entiers, ou le résultat final est une expression du même type. <span class="hljs-attribute">v</span>可以是任何类型，val1和val2可以是同类型的任意值，类型不局限为常量或者整数，或者最终结果为相同类型的表达式。

switch v {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

• select语句
  select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。它将会随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s);
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}

注意：

• 每个case必须都是一个通信
• 所有channel表达式都会被求值，所有被发送的表达式都会被求值
• 如果任意某一个通信都可以，它就执行，其他就忽略
• 如果有多个case都可以运行，select就会随机挑选一个来执行。
• 如果没有一个case可以被运行：如果有default子句，就执行default子句，select将被阻塞，直到某个通信可以运行，从而避免饥饿问题。

2、循环语句

2.1 循环处理语句

与多数语言不同的是，Go语言中的循环语句只支持 for 关键字，而不支持 while 和 do-while 结构，关键字 for 的基本使用方法与C语言和 C++ 中非常接近。

go中时使用for实现循环的，共有三种形式：

for key, value := range oldmap {
	newmap[key] = value
}

instruction select select est une structure de contrôle dans Go, similaire à une instruction switch utilisée pour la communication. Chaque cas doit être une opération de communication

	语法
和c语言中的for相同	for init; condition; post {}
和c语言中的while相同	for condition{}
和c语言中的<span class="hljs-function"><span class="hljs-title">for</span><span class="hljs-params">(;;)</span></span>

, soit en envoi, soit en réception. Il exécutera aléatoirement un cas exécutable. S'il n'y a aucun cas à exécuter, il se bloquera jusqu'à ce qu'il y ait un cas à exécuter. Une clause par défaut doit toujours être exécutable.

a := 0
for a<5 {
	fmt.Printf("%d\n", a)
	a++
	if a==2 {
		break;
	}
}
/* output
0
1
2
*/

Remarque :

Chaque cas doit être une communicationToutes les expressions du canal seront évaluées, toutes les expressions envoyées seront évaluées

Si une communication est OK, elle suffit de l'exécuter, ignorez les autresSi plusieurs cas peuvent être exécutés, select en sélectionnera un au hasard à exécuter. Si aucun cas ne peut être exécuté : s'il existe une clause par défaut, la clause par défaut sera exécutée et la sélection sera bloquée jusqu'à ce qu'une certaine communication puisse s'exécuter, évitant ainsi le problème de famine.

2、 Instruction de boucleDifférent de la plupart des langages, les instructions de boucle dans le langage Go ne prennent en charge que le mot-clé for et ne prennent pas en charge les structures while et do-while. L'utilisation de base du mot-clé for est très proche de celle du langage C et C++. . Il existe trois formes d'utilisation de for pour implémenter des boucles en go : la syntaxe

	2.1 Instructions de traitement de boucle

🎜🎜🎜 est la même que pour le langage C 🎜🎜pour la condition d'initialisation ; 🎜🎜 est le même que while en langage C 🎜🎜for condition{}🎜🎜🎜🎜 et <span class="hljs-function"><span class=" hljs-title ">for</span><span class="hljs-params">(;;)</span></span>Idem 🎜🎜for{}🎜🎜🎜🎜🎜sauf , la boucle for peut utilisez également directement 🎜range🎜 pour parcourir des tranches, des cartes, des tableaux et des chaînes, etc. Le format est le suivant : 🎜

    // 不使用标记
    fmt.Println("---- continue ---- ")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                continue
            }
    }

/* output
i: 1
i2: 11
i2: 12
i2: 13
i: 2
i2: 11
i2: 12
i2: 13
i: 3
i2: 11
i2: 12
i2: 13
*/

    // 使用标记
    fmt.Println("---- continue label ----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d", i)
                for i2 := 11; i2 <= 13; i2++ {
                    fmt.Printf("i2: %d\n", i2)
                    continue re
                }
        }

/* output
i: 1
i2: 11
i: 2
i2: 11
i: 3
i2: 11
*/

🎜🎜🎜🎜2.2 Instruction de contrôle de boucle🎜🎜🎜🎜🎜🎜Instruction de contrôle🎜🎜explication détaillée🎜🎜 🎜 🎜🎜🎜break🎜🎜Interruption hors de la boucle ou instruction switch🎜🎜🎜🎜continue🎜🎜Sautez les instructions restantes de la boucle en cours, puis continuez avec le cycle suivant🎜🎜🎜🎜instruction goto🎜🎜Transférez le contrôle vers le marqué déclaration 🎜🎜🎜🎜

1、break

break主要用于循环语句跳出循环，和c语言中的使用方式是相同的。且在多重循环的时候还可以使用label标出想要break的循环。
实例代码如下：

a := 0
for a<5 {
	fmt.Printf("%d\n", a)
	a++
	if a==2 {
		break;
	}
}
/* output
0
1
2
*/

2、continue

Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。在多重循环中，可以用标号 label 标出想 continue 的循环。
实例代码如下：

    // 不使用标记
    fmt.Println("---- continue ---- ")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                continue
            }
    }

/* output
i: 1
i2: 11
i2: 12
i2: 13
i: 2
i2: 11
i2: 12
i2: 13
i: 3
i2: 11
i2: 12
i2: 13
*/

    // 使用标记
    fmt.Println("---- continue label ----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d", i)
                for i2 := 11; i2 <= 13; i2++ {
                    fmt.Printf("i2: %d\n", i2)
                    continue re
                }
        }

/* output
i: 1
i2: 11
i: 2
i2: 11
i: 3
i2: 11
*/

3、goto

goto语句主要是无条件转移到过程中指定的行。goto语句通常和条件语句配合使用，可用来实现条件转移、构成循环以及跳出循环体等功能。但是并不主张使用goto语句，以免造成程序流程混乱。
示例代码如下：

var a int = 0
LOOP: for a<5 {
	if a == 2 {
		a = a+1
		goto LOOP
	}
	fmt.Printf("%d\n", a)
	a++
}

/*
output:
0
1
2
3
4
*/

以上代码中的LOOP就是一个标签，当运行到goto语句的时候，此时执行流就会跳转到LOOP标志的哪一行上。

【相关推荐：Go视频教程、编程教学】

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!