Mécanisme de gestion des erreurs en langage Go

Le langage Go, en tant que langage de programmation moderne, prend en charge les mécanismes de gestion des erreurs. Ses idées de gestion des erreurs sont claires et simples. Il fournit non seulement des méthodes de gestion des erreurs standard, mais prend également en charge les types d'erreurs personnalisés, ce qui facilite la tâche des développeurs. gestion des erreurs plus flexible.

1. Présentation de la gestion des erreurs

Dans le langage Go, la gestion des erreurs est considérée comme une valeur de retour normale, facile à comprendre. La méthode recommandée dans Go consiste à ce que la fonction renvoie une valeur d'erreur. Si l'appel réussit, elle renvoie une valeur nulle. Sinon, elle renvoie une valeur d'erreur non nulle, généralement un type qui implémente l'interface Error.

Go représente les erreurs via l'interface d'erreur intégrée. error est une interface avec une méthode de chaîne Error(). Tant que le type implémente la méthode de chaîne Error(), elle peut être renvoyée comme valeur d'erreur. Par exemple, utilisez la fonction fmt.Errorf() pour renvoyer une nouvelle valeur d'erreur :

func divide(x, y int) (int, error) {
  if y == 0 {
    return 0, fmt.Errorf("division by zero")
  }
  return x / y, nil
}

La fonction Divide ci-dessus renvoie deux paramètres, le premier est le résultat de x/y et le second est la valeur d'erreur si y est nul. , une nouvelle valeur d'erreur est renvoyée. Nous pouvons appeler cette fonction comme ceci :

res, err := divide(6, 2)
if err != nil {
  fmt.Println(err)
  return
}
fmt.Println("Result is", res)

Notez que lorsque nous appelons la fonction, nous vérifions également si la deuxième valeur de retour est nulle. Si elle n'est pas nulle, cela signifie qu'une erreur s'est produite.

Si nous devons personnaliser le type d'erreur, nous pouvons créer un type pour implémenter l'interface d'erreur :

type myError struct {
  code    int
  message string
}
func (e *myError) Error() string {
  return fmt.Sprintf("Error code %d: %s", e.code, e.message)
}

Ensuite, nous pouvons utiliser ce nouveau type d'erreur de la manière suivante :

func newMyError() error {
  return &myError{100, "custom error message"}
}

2. Meilleures pratiques de gestion des erreurs

1, Vérifiez toutes les erreurs

Dans Go, c'est une bonne habitude de programmation de vérifier toutes les fonctions renvoyant des erreurs. Cela peut nous aider à trouver et à corriger les erreurs potentielles et à garantir que notre programme ne s'interrompra pas lorsqu'une erreur se produit.

2. Les erreurs doivent contenir des informations lisibles

Lorsque nous renvoyons une erreur, nous devons ajouter des informations lisibles, ce qui peut aider les utilisateurs à mieux comprendre la cause de l'erreur.

3. Évitez d'utiliser des variables d'erreur globales

Les variables d'erreur globales ne sont pas recommandées car elles peuvent être utilisées à mauvais escient par d'autres codes non liés. Au lieu de cela, nous devrions renvoyer des variables locales dans des fonctions ou des méthodes, ce qui évite d'exposer des erreurs à d'autres fonctions.

4. Utilisez l'instruction defer

Même si nous renvoyons une valeur d'erreur dans la fonction, nous devrons peut-être encore effectuer certaines opérations de nettoyage, telles que la fermeture du fichier ou la libération de ressources. Pour garantir que ces opérations de nettoyage sont toujours effectuées, nous pouvons utiliser l'instruction defer.

func myFunc() error {
  f, err := os.Open("file.txt")
  if err != nil {
    return err
  }
  defer f.Close()
  //其他代码
  return nil
}

Même après qu'une erreur se produit dans la fonction et revient, l'instruction defer sera exécutée avant le retour de la fonction.

5. La gestion des erreurs ne doit pas gêner l'exécution du programme

Lors de la gestion des erreurs, nous devons nous assurer que les erreurs n'auront pas d'impact négatif sur l'exécution du programme. Par exemple, si nous avons une erreur lors du décodage du JSON, nous pouvons utiliser les valeurs par défaut.

3. Résumé

Le mécanisme de gestion des erreurs du langage Go est un outil simple mais puissant, qui rend la gestion des erreurs très facile, ce qui est une aubaine pour les développeurs du langage Go. Lors de l'écriture de programmes Go, nous devons utiliser de manière flexible le mécanisme de gestion des erreurs et écrire un bon code de gestion des erreurs pour éviter les plantages ou les exceptions après que des erreurs de programme se produisent.

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!