Comment utiliser goto en langage go

Dans le langage go, l'instruction goto est utilisée pour les sauts inconditionnels, qui peuvent être transférés sans condition vers la ligne spécifiée dans le programme ; elle effectue des sauts inconditionnels entre les codes via des étiquettes. goto est suivi d'une étiquette. La signification de cette étiquette est d'indiquer au programme Go quelle ligne de code exécuter ensuite. La syntaxe est "goto label;... ...label: expression;". goto rompt l'ordre d'exécution du code d'origine et passe directement à la ligne spécifiée pour exécuter le code ; l'instruction goto est généralement utilisée conjointement avec des instructions conditionnelles et peut être utilisée pour implémenter des fonctions telles que le transfert conditionnel, la formation d'une boucle et le saut hors de le corps de la boucle.

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

L'instruction goto en langage go

goto Gu Yansi signifie sauter.

L'instruction goto du langage Go peut être transférée sans condition vers la ligne spécifiée dans le programme et sauter sans condition entre les codes via les étiquettes. En même temps, l'instruction goto est également utile pour sortir rapidement des boucles et éviter les sorties répétées. Les déclarations peuvent simplifier le processus de mise en œuvre de certains codes.

La syntaxe de l'instruction goto

goto est suivie d'une étiquette La signification de cette étiquette est d'indiquer au programme Go quelle ligne de code exécuter ensuite.

Alors, comment et où placer cette étiquette est la chose la plus importante à laquelle il faut prêter attention lors de goto. L'organigramme de l'instruction

goto 标签;
...
...
标签: 表达式;

goto est le suivant :

Utilisation de l'instruction goto

• goto peut rompre l'ordre d'exécution du code d'origine et passer directement à une certaine ligne d'exécution du code.

import "fmt"

func main() {

    goto flag
    fmt.Println("B")
flag:
    fmt.Println("A")

}

Le résultat de l'exécution ne produira pas B, mais seules les instructions A

A

• goto sont généralement utilisées en conjonction avec des instructions conditionnelles. Il peut être utilisé pour implémenter un transfert conditionnel, former une boucle, sortir du corps de la boucle et d'autres fonctions.

Voici un exemple d'utilisation de goto pour implémenter une boucle qui imprime 1 à 5.

import "fmt"

func main() {
    i := 1
flag:
    if i <= 5 {
        fmt.Println(i)
        i++
        goto flag
    }
}

Le résultat est le suivant

Un autre exemple, utilisez goto pour obtenir l'effet de type break.

import "fmt"

func main() {
    i := 1
    for {
        if i > 5 {
            goto flag
        }
        fmt.Println(i)
        i++
    }
flag:
}

Le résultat est le suivant

Enfin, à titre d'exemple, utilisez goto pour obtenir l'effet de type continue, en imprimant tous les nombres pairs de 1 à 10.

import "fmt"

func main() {
    i := 1
flag:
    for i <= 10 {
        if i%2 == 1 {
            i++
            goto flag
        }
        fmt.Println(i)
        i++
    }
}

Le résultat est le suivant

Utilisez goto pour quitter les boucles à plusieurs niveaux

Le code suivant doit quitter en permanence les boucles à deux niveaux lorsque les conditions sont remplies. La méthode de codage traditionnelle est la suivante. suit :

package main
import "fmt"
func main() {
    var breakAgain bool
    // 外循环
    for x := 0; x < 10; x++ {
        // 内循环
        for y := 0; y < 10; y++ {
            // 满足某个条件时, 退出循环
            if y == 2 {
                // 设置退出标记
                breakAgain = true
                // 退出本次循环
                break
            }
        }
        // 根据标记, 还需要退出一次循环
        if breakAgain {
                break
        }
    }
    fmt.Println("done")
}

Description du code Comme suit :

• Ligne 10, construisez la boucle extérieure.

• Ligne 13, construisez la boucle intérieure.

• Ligne 16, lorsque y==2, toutes les boucles for doivent être quittées.

• Ligne 19. Par défaut, la boucle ne peut quitter que couche par couche. Pour ce faire, vous devez définir une variable d'état breakAgain. Lorsque vous devez quitter, définissez cette variable sur true.

• À la ligne 22, utilisez break pour quitter la boucle en cours. Après exécution, le code est transféré à la ligne 28.

• Ligne 28, après avoir quitté une couche de la boucle, utilisez la variable breakAgain pour déterminer s'il est nécessaire de quitter à nouveau la couche externe de la boucle.

• Ligne 34, après avoir quitté toutes les boucles, impression terminée.

Optimisez le code ci-dessus à l'aide de l'instruction goto du langage Go :

package main
import "fmt"
func main() {
    for x := 0; x < 10; x++ {
        for y := 0; y < 10; y++ {
            if y == 2 {
                // 跳转到标签
                goto breakHere
            }
        }
    }
    // 手动返回, 避免执行进入标签
    return
    // 标签
breakHere:
    fmt.Println("done")
}

La description du code est la suivante :

• À la ligne 13, utilisez l'instruction goto pour accéder à l'étiquette spécifiée, qui est définie en ligne 23.

• Ligne 20, le label ne peut être utilisé que par goto, mais cela n'affecte pas le processus d'exécution du code. Si vous ne revenez pas manuellement ici, la 24ème ligne de code sera également exécutée lorsque les conditions ne sont pas remplies.

• Ligne 23, définissez la balise breakHere.

Après avoir utilisé l'instruction goto, toutes les boucles peuvent être rapidement quittées sans variables supplémentaires.

Utilisez goto pour gérer les erreurs de manière centralisée

C'est très délicat lorsqu'il y a des duplications de code dans plusieurs gestions d'erreurs, par exemple :

err := firstCheckError()
if err != nil {
    fmt.Println(err)
    exitProcess()
    return
}
err = secondCheckError()
if err != nil {
    fmt.Println(err)
    exitProcess()
    return
}
fmt.Println("done")

La description du code est la suivante :

• Ligne 1, exécutez un certaine logique et renvoie une erreur.

• Ligne 2 ~ 6, si une erreur se produit, imprimez l'erreur et quittez le processus.

• Ligne 8, exécute une certaine logique et renvoie une erreur.

• Lignes 10 à 14, quittez le processus après qu'une erreur se produit.

• Ligne 16, aucune erreur, impression terminée.

Dans le code ci-dessus, une partie est du code de gestion des erreurs répétées. Si d'autres jugements sont ajoutés ultérieurement à ces codes, ces codes similaires devront être modifiés dans l'ordre, ce qui peut facilement conduire à des oublis et des erreurs.

使用 goto 语句来实现同样的逻辑：

    err := firstCheckError()
    if err != nil {
        goto onExit
    }
    err = secondCheckError()
    if err != nil {
        goto onExit
    }
    fmt.Println("done")
    return
onExit:
    fmt.Println(err)
    exitProcess()

代码说明如下：

• 第 3 行和第 9 行，发生错误时，跳转错误标签 onExit。

• 第 17 行和第 18 行，汇总所有流程进行错误打印并退出进程。

注意事项

goto语句与标签之间不能有变量声明，否则编译错误。

import "fmt"

func main() {
    fmt.Println("start")
    goto flag
    var say = "hello oldboy"
    fmt.Println(say)
flag:
    fmt.Println("end")
}

编译错误

.\main.go:7:7: goto flag jumps over declaration of say at .\main.go:8:6

【相关推荐：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!