Conseils pour une sortie élégante et un parcours de boucle hors des fonctions Golang

Golang est un langage de programmation avec une efficacité de développement élevée et d'excellentes performances. Sa puissante fonctionnalité est l'une de ses caractéristiques clés. Au cours du processus de développement, nous rencontrons souvent des situations dans lesquelles nous devons quitter une fonction ou effectuer une boucle. Cet article présentera les astuces de sortie gracieuse et de sortie de parcours de boucle des fonctions Golang.

1. Sortie gracieuse d'une fonction

Dans la programmation Golang, nous devons parfois quitter gracieusement une fonction. Cette situation est généralement due au fait que nous rencontrons des erreurs dans la fonction ou que les résultats d'exécution de la fonction ne sont pas ceux attendus. Il existe deux situations dans lesquelles vous devez envisager la sortie en douceur d'une fonction :

(1) Lorsque la fonction s'exécute avec succès mais ne peut pas renvoyer le résultat correct, vous devez envisager une sortie en douceur.

(2) Lorsqu'une erreur ou une situation anormale se produit lors de l'exécution d'une fonction, une sortie en douceur doit être envisagée.

Alors, comment réaliser une sortie en douceur d'une fonction dans Golang ? Prenons un exemple de code comme exemple pour expliquer.

Exemple de code :

func test() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("recover error:", err)
        }
    }()
    fmt.Println("start test")
    panic("test panic")
    fmt.Println("end test")
}

Dans le code ci-dessus, nous avons créé une fonction de test. Dans la fonction, nous utilisons le mot-clé defer. L'instruction defer retarde l'exécution de la fonction spécifiée. Une fonction anonyme est utilisée ici. Si une erreur de panique se produit pendant l'exécution de la fonction, la fonction de récupération peut capturer l'erreur et la gérer en conséquence.

Nous pouvons le tester en appelant la fonction test :

func main() {
    test()
    fmt.Println("main end")
}

Le résultat de sortie du programme ci-dessus est :

start test
recover error: test panic
main end

Comme indiqué ci-dessus, bien que nous ayons utilisé la fonction panique dans la fonction test pour provoquer une erreur, nous avons utilisé la récupération fonction pour le capturer. Des erreurs et des messages d'invite sont générés pour éviter les plantages du programme.

2. Sortir du parcours de boucle

Dans Golang, l'instruction for peut être utilisée pour effectuer un parcours de boucle. Lors du parcours de boucle, nous devons parfois sortir de la boucle sous certaines conditions. Ci-dessous, nous présenterons plusieurs conseils pour sortir du parcours de boucle.

(1) Utilisez l'instruction break pour sortir de la boucle

L'instruction break est utilisée pour sortir de l'instruction de boucle en cours d'exécution. Utilisez l'instruction break dans une boucle for pour terminer la boucle plus tôt.

Exemple de code :

for i := 0; i < 10; i++ {
    if i == 5 {
        break
    }
    fmt.Println(i)
}

Dans le code ci-dessus, nous utilisons une boucle for pour parcourir les entiers compris entre 0 et 10. Lorsque la valeur de i est égale à 5, nous utilisons l’instruction break pour sortir de la boucle.

(2) Utilisez l'instruction continue pour ignorer cette boucle

L'instruction continue est utilisée pour ignorer les instructions restantes dans la boucle actuelle et entrer dans l'itération suivante de la boucle. L'utilisation de l'instruction continue dans une boucle for permet à la boucle de sauter cette boucle si certaines conditions sont remplies.

Exemple de code :

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

Dans le code ci-dessus, nous utilisons une boucle for pour parcourir les entiers compris entre 0 et 10. Lorsque la valeur de i est égale à 5, nous utilisons l'instruction continue pour ignorer cette boucle.

(3) Utilisez l'instruction goto pour accéder à la position de l'étiquette

L'instruction goto peut faire sauter le programme à la ligne où se trouve l'étiquette. L'utilisation d'instructions goto dans le parcours de boucle peut réaliser des sauts conditionnels plus complexes.

Exemple de code :

for i := 0; i < 10; i++ {
    for j := 0; j < 10; j++ {
        if j == 5 {
            goto breakfor
        }
        fmt.Printf("(%d,%d)
", i, j)
    }
}
breakfor:
fmt.Println("break for")

Dans le code ci-dessus, nous utilisons deux boucles for pour parcourir de manière imbriquée le tableau bidimensionnel. Dans la boucle interne, lorsque la valeur de j est égale à 5, nous utilisons l'instruction goto pour accéder à l'emplacement de l'étiquette breakfor.

Résumé :

Cet article présente principalement les astuces de sortie gracieuse et de sortie de parcours de boucle des fonctions Golang. Dans le développement de Golang, les fonctions et les parcours de boucles sont des fonctionnalités très couramment utilisées, et leur utilisation flexible peut améliorer l'efficacité de notre développement et les performances de nos programmes. J'espère que cet article sera utile aux lecteurs.

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!