Gestion des erreurs dans Go : comment écrire un bon code de gestion des erreurs

Quel que soit le langage de programmation dans lequel vous travaillez, la gestion des erreurs est un élément essentiel. Dans le langage Go, il existe un bon mécanisme de gestion des erreurs qui peut aider les programmeurs à gérer facilement les erreurs et les exceptions. Cet article se concentrera sur la façon d'écrire un excellent code de gestion des erreurs pour améliorer la qualité du code et la stabilité du programme.

1. Connaissance de base de la gestion des erreurs

Dans le langage Go, les erreurs sont considérées comme des valeurs ordinaires, qui peuvent être traitées et transmises. Chaque fonction peut renvoyer une valeur de type erreur. Si une erreur se produit, elle renverra une valeur d'erreur non nulle, sinon elle renverra zéro.

Le type d'erreur dans le langage Go est l'interface intégrée de type error, qui n'a qu'une seule méthode :

type error interface {

Error() string

}

Cette interface définit une méthode Error(), qui renvoie une chaîne indiquant les informations d’erreur.

Par conséquent, nous pouvons utiliser if err != nil pour déterminer si une erreur s'est produite, nous pouvons la gérer en conséquence en fonction de la situation spécifique. Dans des circonstances normales, nous utiliserons le package de journaux pour générer des informations de journal, renvoyer des informations d'erreur à l'appelant de niveau supérieur ou prendre des mesures supplémentaires pour éviter que des erreurs ne se reproduisent.

2. Meilleures pratiques pour la gestion des erreurs

2.1 Renvoyer des messages d'erreur clairs

Le bon mécanisme de gestion des erreurs du langage Go peut fournir aux utilisateurs des messages d'erreur plus clairs et les aider à trouver rapidement le problème. Par conséquent, lors de l’écriture de programmes Go, il est préférable de fournir des informations claires sur chaque erreur afin que les utilisateurs puissent rapidement localiser et résoudre le problème.

Par exemple :

if _, err := os.Open(filePath); err != nil {

return fmt.Errorf("failed to open file %s: %v", filePath, err)

}

Dans le code ci-dessus, fmt.Errorf() est utilisé pour envelopper le message d'erreur et fournir effacer Message d'erreur : une erreur s'est produite lors de l'ouverture du fichier, y compris le nom de fichier spécifique et le message d'erreur.

2.2 Lorsque vous n'avez pas besoin d'un type d'erreur spécifique, utilisez error.New() pour créer des erreurs

En langage Go, il est très pratique d'utiliser error.New() pour créer des erreurs. Si nous devons renvoyer une erreur qui ne contient pas d’informations spécifiques, nous pouvons utiliser error.New() pour créer une nouvelle erreur.

Par exemple :

return error.New("quelque chose s'est mal passé")

2.3 Évitez les erreurs imbriquées

Lors du traitement des erreurs, vous pouvez rencontrer des erreurs imbriquées, c'est-à-dire qu'une erreur peut conduire à une erreur plus importante. À l’heure actuelle, nous devons gérer les erreurs avec soin pour éviter les erreurs imbriquées.

Une façon d'éviter les erreurs imbriquées consiste à séparer la fonction dans laquelle des erreurs imbriquées peuvent se produire dans une autre fonction qui gère toutes les erreurs.

Par exemple :

func doSomething() error {

if _, err := os.Open(filePath); err != nil {
    return fmt.Errorf("failed to open file %s: %v", filePath, err)
}
// do something
return nil

}

func main() {

if err := doSomething(); err != nil {
    log.Fatalf("failed to do something: %v", err)
}

}

Dans le code ci-dessus, nous décomposons la fonction sujette aux erreurs doSomething() en deux fonctions, ce qui évite le problème des erreurs imbriquées, et le code est plus clair et plus facile à comprendre.

2.4 Utilisez des points-virgules pour séparer les erreurs sur plusieurs lignes

Dans le langage Go, les erreurs occupent généralement plusieurs lignes. À l'heure actuelle, des points-virgules doivent être utilisés pour séparer les erreurs afin de les rendre claires et faciles à lire.

Par exemple :

if value < minValue || value > maxValue {

return fmt.Errorf(
    "value %d is out of range [%d, %d]; %s",
    value, minValue, maxValue, errAdditionalInfo)

}

Dans le code ci-dessus, nous utilisons des points-virgules pour séparer plusieurs lignes d'erreurs afin de rendre le message d'erreur plus clair et plus facile à lire.

3. Panique et récupération en langage Go

En plus du mécanisme de gestion des erreurs ci-dessus, le langage Go fournit également des mécanismes de panique et de récupération pour gérer les erreurs graves et récupérer les programmes.

Lorsqu'une erreur irrécupérable se produit dans le programme, vous pouvez utiliser la fonction panic() pour lever une exception. À ce moment, le programme arrêtera immédiatement l'exécution et imprimera un message d'erreur.

Par exemple :

func doSomething() {

if _, err := os.Open(filePath); err != nil {
    panic(fmt.Sprintf("failed to open file %s: %v", filePath, err))
}
// do something

}

Dans le code ci-dessus, si une erreur se produit lors de l'ouverture du fichier, le programme arrêtera immédiatement l'exécution et lèvera une exception.

D'autre part, la fonction recovery() peut reprendre l'exécution du programme après qu'une panique se soit produite dans le programme. La fonction recovery() ne peut être utilisée que dans la fonction defer, qui est utilisée pour intercepter la panique et empêcher la panique de passer à la couche externe.

Par exemple :

func main() {

defer func() {
    if err := recover(); err != nil {
        log.Fatalf("recover from panic: %v", err)
    }
}()
doSomething()

}

Dans le code ci-dessus, nous utilisons la fonction defer plus recovery() pour reprendre l'exécution du programme. Lorsqu'un programme panique, la fonction recovery() sera appelée dans la fonction defer pour capturer les informations de panique et d'erreur d'impression.

4. Résumé

Une excellente gestion des erreurs est un signe de qualité du code et peut rendre le code plus robuste et plus sécurisé. Dans le langage Go, un bon mécanisme de gestion des erreurs peut facilement gérer et transmettre les erreurs, et les fonctions de panique et de récupération peuvent être utilisées pour gérer les erreurs graves et reprendre l'exécution du programme. Afin d'écrire un bon code de gestion des erreurs, nous devons suivre les meilleures pratiques et toujours prêter attention à la clarté et à la clarté des messages d'erreur.

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!