Une discussion approfondie sur les sauts de la déclaration Golang

Golang est un langage de programmation orienté objet avec une puissante fonction d'instruction de saut qui permet aux programmeurs d'être plus flexibles et efficaces lors de l'écriture de programmes. Dans cet article, nous approfondirons les sauts d'instructions Golang.

1. Qu'est-ce que le saut de déclaration Golang ?

Le saut d'instruction Golang fait référence à l'utilisation d'instructions de saut dans le programme. Lorsque le programme exécute une certaine ligne de code, il passe à une autre ligne de code spécifiée pour continuer l'exécution, modifiant ainsi le flux d'exécution du programme.

Les instructions de saut couramment utilisées dans Golang incluent break, continue, goto, return, etc. Ces instructions de saut peuvent permettre au programme de s'exécuter selon vos propres besoins.

2. Instruction Break

L'instruction break peut faire sortir le programme de la boucle actuelle ou de l'instruction de sélection (telle que l'instruction switch) et continuer à exécuter le code suivant.

Ce qui suit est un exemple de programme :

package main

import "fmt"

func main() {
    for i := 1; i <= 10; i++ {
        if i == 5 {
            break
        }
        fmt.Println(i)
    }   
    fmt.Println("程序继续执行...")
}

Ce programme utilise une boucle for pour parcourir une séquence entière de 1 à 10, et utilise l'instruction if pour déterminer si i est égal à 5, puis utilise l'instruction break pour sauter de la boucle et continuez à exécuter le code suivant. Exécutez le programme et le résultat de sortie est :

1
2
3
4
程序继续执行...

Le résultat de sortie montre que lorsque i est égal à 5, la boucle est sautée et le code suivant continue d'être exécuté.

3. Instruction Continue

L'instruction continue permet au programme de sauter le code restant dans la boucle en cours et d'entrer directement dans la boucle suivante.

Ce qui suit est un exemple de programme :

package main

import "fmt"

func main() {
    for i := 1; i <= 10; i++ {
        if i == 5 {
            continue
        }
        fmt.Println(i)
    }
}

Ce programme utilise une boucle for pour parcourir une séquence entière de 1 à 10, et utilise l'instruction if pour déterminer si i est égal à 5, puis utilise l'instruction continue pour ignorer le code suivant et entrez directement la boucle suivante. Exécutez le programme et le résultat de sortie est :

1
2
3
4
6
7
8
9
10

Le résultat de sortie montre que lorsque i est égal à 5, le code suivant est ignoré et la boucle suivante est entrée directement.

4. Instruction goto

L'instruction goto permet au programme de passer à une ligne de code spécifiée pour une exécution dans des conditions spécifiques, contrôlant ainsi le flux d'exécution du programme. Cependant, comme les instructions goto peuvent facilement conduire à une confusion dans le code et à des difficultés de maintenance, nous devrions essayer d'éviter d'utiliser des instructions goto à moins que cela ne soit absolument nécessaire.

Voici un exemple de programme :

package main

import "fmt"

func main() {
    num := 1
    loop:
    fmt.Println(num)
    num++
    if num <= 10 {
        goto loop
    }
    fmt.Println("程序继续执行...")
}

Ce programme utilise des instructions goto pour accéder à des lignes de code spécifiées dans des conditions spécifiques, et utilise des étiquettes (c'est-à-dire des boucles) pour marquer des lignes de code spécifiques. Exécutez le programme et le résultat de sortie est :

1
2
3
4
5
6
7
8
9
10
程序继续执行...

Comme le montre le résultat de sortie, l'instruction goto est utilisée pour passer avec succès à la ligne de code spécifiée.

5. Return Statement

L'instruction return peut quitter la fonction et renvoyer une valeur (le cas échéant) à l'appelant.

Ce qui suit est un exemple de programme :

package main

import "fmt"

func sum(a int, b int) int {
    return a + b
}

func main() {
    result1 := sum(1, 2)
    result2 := sum(3, 4)
    fmt.Println(result1)
    fmt.Println(result2)
}

Le programme définit une fonction somme pour calculer la somme de deux entiers, appelle la fonction deux fois dans la fonction principale et utilise l'instruction fmt.Println pour afficher le résultat des deux appels. Exécutez le programme et le résultat de sortie est :

3
7

À partir du résultat de sortie, nous pouvons voir que le programme a réussi à quitter la fonction et a renvoyé une valeur à l'appelant.

6. Résumé

Cet article présente les connaissances pertinentes sur les sauts d'instructions Golang, y compris les instructions de saut telles que break, continue, goto et return. Lors de l'écriture d'un programme, nous devons choisir les instructions de saut appropriées en fonction de la situation réelle afin que le programme puisse être exécuté selon nos propres besoins. Dans le même temps, nous devons également faire attention à ne pas abuser des instructions goto pour éviter de confondre le code et de rendre sa maintenance difficile.

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!