Comment terminer le saut dans Golang

Golang est un langage de programmation efficace, sûr et stable, et sa prise en charge des sauts est également excellente. Dans Golang, nous pouvons utiliser le mot-clé jump pour contrôler le flux d'exécution du programme et répondre à certains besoins spécifiques.

1. Mots-clés de saut de Golang

Golang propose trois mots-clés de saut : goto, break et continue. Ils sont utilisés pour mettre en œuvre différentes exigences de saut.

1. instruction goto

L'instruction goto peut accéder directement à l'étiquette spécifiée dans le programme, par exemple :

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            goto LOOP
        }
        fmt.Println(i)
    }
LOOP:
    fmt.Println("Loop Done!")
}

Dans le code ci-dessus, lorsque la valeur de i est 5, elle passe à l'étiquette LOOP pour exécution. Étant donné que l'instruction goto peut accéder à n'importe quelle étiquette, nous devons l'utiliser avec beaucoup de prudence, sinon cela entraînerait de la confusion et de l'imprévisibilité dans le déroulement du programme.

2. instruction break

L'instruction break peut être utilisée pour sortir des boucles ou changer d'instruction. Par exemple :

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            break
        }
        fmt.Println(i)
    }
    fmt.Println("Loop Done!")
}

Dans le code ci-dessus, lorsque la valeur de i est 5, sortez de la boucle for. L'instruction break sautera uniquement hors de la boucle ou de l'instruction switch actuelle et ne passera pas à l'étiquette spécifiée.

3. instruction continue

l'instruction continue peut être utilisée pour ignorer certaines opérations dans la boucle en cours et continuer à exécuter la boucle suivante. Par exemple :

func main() {
    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            continue
        }
        fmt.Println(i)
    }
    fmt.Println("Loop Done!")
}

Dans le code ci-dessus, la valeur de i sera imprimée uniquement lorsque i n'est pas un nombre pair. Par conséquent, lorsque i est un nombre pair, utilisez l'instruction continue pour ignorer l'opération de boucle en cours.

2. Le mécanisme de gestion des erreurs de Golang

Dans Golang, la gestion des erreurs est une partie très importante. Golang fournit une interface d'erreur standard Error, qui définit une méthode Error() via laquelle les détails de l'erreur peuvent être renvoyés.

Lorsqu'une fonction renvoie une erreur, nous pouvons déterminer si la fonction a été exécutée avec succès en jugeant si la valeur de retour est vide. Par exemple :

func readFile(path string) (string, error) {
    file, err := os.Open(path)
    if err != nil {
        return "", err
    }
    defer file.Close()

    content, err := ioutil.ReadAll(file)
    if err != nil {
        return "", err
    }

    return string(content), nil
}

func main() {
    content, err := readFile("test.txt")
    if err != nil {
        fmt.Printf("Error: %s
", err.Error())
        return
    }
    fmt.Println(content)
}

Dans le code ci-dessus, la fonction readFile lira le contenu du fichier spécifié et le renverra si une erreur se produit, elle renverra un objet d'erreur non vide. Dans la fonction principale, déterminez d'abord si l'objet d'erreur est vide. Sinon, imprimez le message d'erreur et retournez le contenu du fichier.

3. Résumé

Le mot-clé de saut et le mécanisme de gestion des erreurs de Golang sont très pratiques et peuvent nous aider à mieux contrôler le flux d'exécution du programme et à gérer les erreurs. Cependant, lorsque nous utilisons des mots-clés de saut, nous devons être particulièrement prudents pour éviter de provoquer de la confusion et de l'imprévisibilité dans le déroulement du programme. Dans le codage réel, les mots-clés de saut et les mécanismes de gestion des erreurs doivent être utilisés raisonnablement en fonction des besoins spécifiques, afin de créer un programme Golang efficace et stable.

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!