Comment gérez-vous les erreurs dans GO?

Comment gérez-vous les erreurs dans GO?

Dans GO, la gestion des erreurs est principalement gérée à l'aide du type error , qui est une interface définie dans le package builtin comme suit:

 <code class="go">type error interface { Error() string }</code>

Tout type qui implémente cette interface peut être considéré comme une erreur. L'approche de GO pour la gestion des erreurs est explicite et encourage les développeurs à vérifier et à gérer les erreurs immédiatement après leur arrivée. Le modèle commun pour gérer les erreurs dans GO est de vérifier la valeur de retour d'erreur après les appels de fonction et de décider quoi faire en fonction de la question de savoir si une erreur s'est produite. Voici un exemple simple:

 <code class="go">result, err := someFunction() if err != nil { // Handle the error fmt.Println("An error occurred:", err) return } // Use result safely</code>

Dans GO, les fonctions peuvent renvoyer plusieurs valeurs, et c'est une convention pour renvoyer une erreur comme dernière valeur. Lorsque vous rédigez des fonctions, vous devez toujours considérer les erreurs qui peuvent se produire et les renvoyer de manière appropriée. Par exemple:

 <code class="go">func divide(a, b int) (int, error) { if b == 0 { return 0, errors.New("division by zero") } return a / b, nil }</code>

Lorsque vous appelez divide , vous gériez l'erreur comme ceci:

 <code class="go">quotient, err := divide(10, 2) if err != nil { log.Fatal(err) } fmt.Println(quotient) // Output: 5</code>

Quelles sont les meilleures pratiques pour la gestion des erreurs en Go?

La gestion efficace des erreurs dans GO implique plusieurs meilleures pratiques pour vous assurer que votre code est robuste et maintenable:

1. Vérifiez toujours les erreurs: n'ignorez jamais les erreurs. Vérifiez-les toujours et gérez-les de manière appropriée, même si elle ne fait que l'exploitation de l'erreur et l'exécution continue.
2. Soyez précis: lors de la création d'erreurs, soyez aussi spécifique que possible. Cela facilite le débogage et la gestion des types d'erreurs spécifiques.

3. Utilisez l'enveloppe: GO 1.13 Introduit Erreur Emballage, ce qui vous permet d'ajouter un contexte à une erreur sans perdre l'erreur d'origine. Utilisez fmt.Errorf avec le verbe %w pour envelopper les erreurs.

    <code class="go">err := fmt.Errorf("failed to read file: %w", os.ErrNotExist)</code>

4. Créez des types d'erreur personnalisés: si nécessaire, définissez les types d'erreur personnalisés pour des scénarios plus complexes. Cela peut aider à distinguer les différents types d'erreurs et à les manipuler différemment.

5. Utilisez des fonctions différées: utilisez des fonctions différées pour gérer les ressources et le nettoyage, qui peuvent également être utilisées pour la gestion des erreurs, en particulier avec recover .

    <code class="go">defer func() { if r := recover(); r != nil { fmt.Println("Recovered from panic:", r) } }()</code>

6. Journalisation: utilisez la journalisation structurée pour enregistrer les erreurs avec un contexte supplémentaire. Cela aide à déboguer et à surveiller.
7. Stratégies de traitement des erreurs: décidez d'une stratégie de gestion des erreurs au début de votre projet. Allez-vous réessayer les opérations, échouer rapidement ou vous connecter et continuer? La cohérence de la gestion des erreurs à travers la base de code est cruciale.
8. Documentation: documenter comment les erreurs sont gérées dans votre API et quelles erreurs peuvent être renvoyées par vos fonctions. Cela rend votre code plus compréhensible et maintenable.

Comment pouvez-vous créer des types d'erreurs personnalisés dans GO?

La création de types d'erreur personnalisés dans GO peut être utile pour une gestion des erreurs plus détaillée et pour distinguer les différents types d'erreurs. Voici comment définir un type d'erreur personnalisé:

1. Définissez le type d'erreur: vous pouvez définir un type d'erreur personnalisé en créant une structure qui implémente l'interface error .

    <code class="go">type MyError struct { Code int Message string } func (e *MyError) Error() string { return fmt.Sprintf("Error %d: %s", e.Code, e.Message) }</code>

2. Utilisez l'erreur personnalisée: une fois défini, vous pouvez utiliser votre type d'erreur personnalisé dans vos fonctions.

    <code class="go">func doSomething() error { // Some operation fails return &MyError{Code: 404, Message: "Resource not found"} }</code>

3. Vérifiez le type d'erreur personnalisé: vous pouvez vérifier le type d'erreur personnalisé à l'aide des assertions de type.

    <code class="go">err := doSomething() if err != nil { if e, ok := err.(*MyError); ok { fmt.Printf("Custom error: Code %d, Message %s\n", e.Code, e.Message) } else { fmt.Println("Unknown error:", err) } }</code>

4. Erreur d'erreur: vous pouvez également envelopper votre erreur personnalisée avec un contexte supplémentaire en utilisant fmt.Errorf et %w .

    <code class="go">err := doSomething() if err != nil { return fmt.Errorf("operation failed: %w", err) }</code>

Quels outils ou bibliothèques peuvent aider à la gestion des erreurs dans GO?

Plusieurs outils et bibliothèques peuvent aider à améliorer la gestion des erreurs dans GO:

1. PKG / ERRORS: Le package github.com/pkg/errors fournit des fonctionnalités supplémentaires de gestion des erreurs, telles que des traces de pile, qui peuvent être très utiles pour le débogage. Il prend également en charge l'enveloppement d'erreurs, qui a ensuite été incorporé dans la bibliothèque standard.

    <code class="go">err := errors.New("original error") wrappedErr := errors.Wrap(err, "additional context")</code>

2. Uber-Go / Zap: cette bibliothèque de journalisation fournit une journalisation structurée, rapide et nivelée. Il est particulièrement utile pour enregistrer les erreurs avec un contexte supplémentaire.

    <code class="go">logger := zap.NewExample() defer logger.Sync() sugar := logger.Sugar() sugar.Infow("Failed to fetch URL.", "url", url, "attempt", 3, "backoff", time.Second, )</code>

3. Go-Chi / Chi: Si vous construisez un service Web, le routeur github.com/go-chi/chi dispose d'un middleware intégré pour la manipulation et la journalisation des erreurs standardisées.

    <code class="go">r := chi.NewRouter() r.Use(middleware.Recoverer) r.Get("/", func(w http.ResponseWriter, r *http.Request) { w.Write([]byte("hello world")) })</code>

4. ErrGroup: à partir du package golang.org/x/sync/errgroup , errgroup.Group aide à gérer les goroutines et leurs erreurs de manière centralisée.

    <code class="go">g := new(errgroup.Group) g.Go(func() error { // do something return nil }) if err := g.Wait(); err != nil { log.Fatal(err) }</code>

5. github.com/hashicorp/go-multierror: Ce package vous permet de combiner plusieurs erreurs en une seule erreur, ce qui peut être utile lors de la gestion de plusieurs opérations qui pourraient échouer.

    <code class="go">var errs error errs = multierror.Append(errs, errors.New("first error")) errs = multierror.Append(errs, errors.New("second error")) if errs != nil { log.Fatal(errs) }</code>

L'utilisation de ces outils et de ces bibliothèques peut considérablement améliorer votre stratégie de traitement des erreurs en Go, ce qui rend vos applications plus robustes et plus faciles à déboguer et à maintenir.

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!