Méthode de gestion des exceptions du mot-clé defer dans la fonction Golang

Golang est un langage de programmation relativement émergent, open source et performant. L'une de ses fonctionnalités est le mot-clé defer des fonctions. Ce mot-clé nous permet d'effectuer certaines opérations requises avant la fin de la fonction, telles que le nettoyage des ressources, la sortie du journal, etc. Il peut également être utilisé pour gérer les exceptions, rendant notre code plus robuste et fiable. Cet article explorera en profondeur l'application du mot-clé defer des fonctions Golang dans la gestion des exceptions, afin que les lecteurs puissent utiliser cette fonctionnalité plus habilement.

1. Comment utiliser defer

Dans Golang, le mot-clé defer peut être utilisé pour définir un appel de fonction, qui sera exécuté une fois la fonction terminée. La particularité de defer est qu'il sera exécuté avant le retour de la fonction, qu'une exception se produise ou non au milieu de la fonction. Par exemple :

func demo() {
    defer fmt.Println("defer end.")
    fmt.Println("normal flow.")
}

Dans le code ci-dessus, l'instruction print "normal flow." sera exécutée avant l'instruction defer "defer fmt.Println("defer end.")".

De plus, si plusieurs instructions defer sont utilisées dans une fonction, leur ordre d'exécution est sur la pile et le defer défini ultérieurement sera exécuté en premier. Par exemple :

func demo() {
    defer fmt.Println("defer 1.")
    defer fmt.Println("defer 2.")
    fmt.Println("normal flow.")
}

Dans le code ci-dessus, l'instruction « flux normal » est imprimée en premier, puis « différer 2. » et enfin « différer 1. ».

2. Différer la gestion des exceptions

En plus de l'utilisation normale, defer peut également être utilisé pour gérer les exceptions dans le code. Une exception est une erreur qui se produit pendant l'exécution du programme. Elle peut être due à de nombreuses raisons, telles qu'une entrée illégale, des erreurs logiques ou des erreurs système. Dans Golang, nous pouvons gérer les exceptions grâce aux trois mots-clés panic/defer/recover. Parmi eux, la panique provoquera une exception ; recovery interceptera l'exception et la gérera ; et defer effectuera certaines opérations de nettoyage nécessaires une fois l'exception traitée. Ce qui suit est un exemple pratique pour illustrer l'utilisation de panic/defer/recover :

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

Dans le code ci-dessus, nous appelons une fonction catchError, imprimons d'abord l'instruction "start", puis utilisons panic pour provoquer une exception, et Output "Une erreur se produit!". À ce moment-là, le programme s'interrompra et entrera dans le report défini par la fonction catchError. Dans ce report, il y a une instruction if pour déterminer si une exception est actuellement interceptée. Si une exception est interceptée, fmt.Println sera appelé et "récupéré à partir de :" et les informations sur l'exception seront affichées.

Cet exemple montre que les mots-clés panic/defer/recover de Golang peuvent être utilisés pour gérer le programme en conséquence lorsqu'une exception se produit dans la fonction. Étant donné que le mot-clé defer sera exécuté dans toutes les circonstances, nous pouvons utiliser defer pour effectuer certaines opérations de nettoyage nécessaires lorsqu'une exception se produit dans le programme, comme la fermeture de fichiers, la libération de ressources, etc.

3. Notes sur defer

Lorsque nous utilisons le mot-clé defer, nous devons prêter attention aux points suivants :

1. Pour defer dans une structure en boucle, une attention particulière doit être portée à son timing d'exécution.

func testLoop() {
    for i := 0; i < 5; i++ {
        defer fmt.Println("defer: ",i)
    }
    fmt.Println("test loop done.")
}

Dans le code ci-dessus, nous utilisons une structure de boucle pour différer les tests. Nous voulons que l'instruction defer soit exécutée en premier à la fin de chaque boucle afin que nous puissions libérer les ressources utilisées dans la boucle. Mais dans le code ci-dessus, puisque l'instruction defer est exécutée en LIFO (dernier entré, premier sorti), ce que nous imprimons finalement est « boucle de test terminée ». "Comment le résoudre ? Une solution consiste à modifier le code en :

func testLoop() {
    for i := 0; i < 5; i++ {
        defer func(i int) {
            fmt.Println("defer: ", i)
        }(i)
    }
    fmt.Println("test loop done.")
}

De cette façon, on ajoute une fermeture à l'instruction defer et on transmet la valeur i actuelle directement à la fonction de fermeture, afin qu'elle puisse appeler la valeur correcte lors de son exécution ultérieure. Comme vous pouvez le voir, après avoir modifié le code pour cette méthode, nous avons imprimé avec succès « boucle de test terminée ». et "defer : 4, defer : 3, ..., defer : 0.".

2. Lors de l'utilisation du report, nous devons également faire attention à l'impact sur les performances qu'il apporte. Parce que chaque instruction defer augmente la surcharge du programme. Par conséquent, le nombre de fois que le report est utilisé dans un programme ou une fonction doit être contrôlé dans une plage raisonnable pour éviter d'affecter les performances du programme.
3. N'essayez pas de modifier les paramètres dans l'instruction defer car ils sont calculés lors de leur définition. Dans ce cas, cela peut apporter des résultats inattendus.
4. Si l'instruction defer du mot-clé contient la fonction go, alors la goroutine sera appelée à la fin de l'exécution de la fonction et n'affectera pas l'exécution de la fonction principale.

4. Résumé

Dans Golang, le mot-clé defer est une fonctionnalité très importante. Il peut être utilisé pour effectuer des opérations de nettoyage de fonctions, telles que la fermeture de fichiers, la libération de ressources, etc. De plus, lorsqu'une exception se produit dans une fonction, l'instruction defer peut également jouer un certain rôle dans la détection et la gestion des exceptions. Lors de l'utilisation du report, nous devons maîtriser son utilisation et prêter attention aux précautions pertinentes afin d'utiliser pleinement cette fonctionnalité dans le développement du programme et de rendre notre programme plus robuste et fiable.

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!