Instruction break du langage Go
Instructions de boucle du langage Go
Dans le langage Go, l'instruction break est utilisée pour terminer l'exécution de la boucle ou de l'instruction switch en cours, et sortir du bloc de code de cette boucle ou de cette instruction switch.
L'instruction break peut être utilisée dans les aspects suivants :.
- Elle est utilisée pour sortir de la boucle dans une instruction de boucle, et commencer à exécuter les instructions après la boucle.
- L'instruction break dans une instruction switch est utilisée pour sortir de l'instruction après l'exécution d'un case.
- break peut être appliqué dans les instructions select.
- Dans les boucles multiples, une étiquette peut être utilisée pour marquer la boucle à quitter.
Syntaxe
Le format de la syntaxe de break est le suivant :
break
L'organigramme de l'instruction break est le suivant :

Exemple
Utilisation de break dans une boucle for :
Exemple
import "fmt"
func main() {
for i := 0; i < 10; i++ {
if i == 5 {
break // Sortir de la boucle lorsque i est égal à 5
}
fmt.Println(i)
}
}
Résultat de sortie :
0 1 2 3 4
Sortir de la boucle lorsque la variable a est supérieure à 15 :
Exemple
import "fmt"
func main() {
/* Définir les variables locales */
var a int = 10
/* boucle for */
for a < 20 {
fmt.Printf("La valeur de a est : %d\n", a);
a++
if a > 15 {
/* Utiliser l'instruction break pour sortir de la boucle lorsque a est supérieur à 15 */
break
}
}
}
Dans l'exemple ci-dessus, lorsque la valeur de a est supérieure à 15, l'instruction break est exécutée et la boucle entière est interrompue. Le résultat de l'exécution est :
a 的值为 : 10 a 的值为 : 11 a 的值为 : 12 a 的值为 : 13 a 的值为 : 14 a 的值为 : 15
L'exemple suivant comporte plusieurs boucles et illustre la différence entre l'utilisation d'étiquettes et l'absence d'étiquettes :
Exemple
import "fmt"
func main() {
// sans étiquette
fmt.Println("---- break ----")
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for i2 := 11; i2 <= 13; i2++ {
fmt.Printf("i2: %d\n", i2)
break
}
}
// en utilisant une étiquette
fmt.Println("---- étiquette break ----")
re:
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for i2 := 11; i2 <= 13; i2++ {
fmt.Printf("i2: %d\n", i2)
break re
}
}
}
Le résultat d'exécution de l'exemple ci-dessus est :
---- break ---- i: 1 i2: 11 i: 2 i2: 11 i: 3 i2: 11 ---- break label ---- i: 1 i2: 11
Utilisation de break dans une instruction switch :
Exemple
func main() {
day := "mardi"
switch day {
case "lundi":
fmt.Println("C'est lundi.")
case "mardi":
fmt.Println("C'est mardi.")
break // Sortir de l'instruction switch
case "mercredi":
fmt.Println("C'est mercredi.")
}
}
Résultat de sortie :
It's Tuesday.
Utilisation de break dans une instruction select :
Exemple
import (
"fmt"
"time"
)
func main() {
ch1 := make(chan int)
ch2 := make(chan int)
go func() {
time.Sleep(2 * time.Second)
ch1 <- 1
}()
go func() {
time.Sleep(1 * time.Second)
ch2 <- 2
}()
select {
ce <-ch1:
fmt.Println("Reçu de ch1.")
case <-ch2:
fmt.Println("Reçu de ch2.")
break // Sortir de l'instruction select
}
}
Résultat de sortie :
Received from ch2.
En langage Go, l'application de l'instruction break dans une instruction select est relativement particulière. En raison des caractéristiques de l'instruction select, l'instruction break ne peut pas être utilisée directement pour sortir de l'instruction select elle-même, car l'instruction select est non bloquante et elle attendra toujours que toutes les opérations de communication soient prêtes. Si vous devez terminer prématurément l'exécution de l'instruction select, vous pouvez utiliser les instructions return ou goto pour obtenir le même effet.
L'exemple suivant montre le cas d'utilisation de return dans une instruction select pour terminer l'exécution prématurément :
Exemple
import (
"fmt"
"time"
)
func process(ch chan int) {
for {
select {
case val := <-ch:
fmt.Println("Valeur reçue :", val)
// Exécuter de la logique
if val == 5 {
return // Terminer prématurément l'exécution de l'instruction select
}
default:
fmt.Println("Aucune valeur reçue pour le moment.")
time.Sleep(500 * time.Millisecond)
}
}
}
func main() {
ch := make(chan int)
go process(ch)
time.Sleep(2 * time.Second)
ch <- 1
time.Sleep(1 * time.Second)
ch <- 3
time.Sleep(1 * time.Second)
ch <- 5
time.Sleep(1 * time.Second)
ch <- 7
time.Sleep(2 * time.Second)
}
Dans l'exemple ci-dessus, la fonction process utilise une instruction select dans une boucle infinie pour attendre des données sur le canal ch. Lorsque des données sont reçues, une certaine logique est exécutée. Lorsque la valeur reçue est égale à 5, return est utilisé pour terminer prématurément l'exécution de l'instruction select.
Résultat de sortie :
No value received yet. No value received yet. Received value: 1 No value received yet. Received value: 3 No value received yet. Received value: 5
En utilisant return, nous pouvons terminer prématurément l'exécution dans l'instruction select et revenir au code de l'appelant.
Il convient de noter que l'utilisation de l'instruction return mettra immédiatement fin à l'exécution de la fonction actuelle, donc veuillez décider en fonction des besoins réels quelle méthode utiliser pour terminer prématurément l'exécution dans l'instruction select.
autres extensions