Maison >développement back-end >Golang >Comment les programmeurs Go peuvent-ils gérer efficacement plusieurs erreurs simultanément ?

Comment les programmeurs Go peuvent-ils gérer efficacement plusieurs erreurs simultanément ?

DDD
DDDoriginal
2024-11-28 21:51:11437parcourir

How Can Go Programmers Efficiently Manage Multiple Errors Concurrently?

Gérer plusieurs erreurs simultanément dans Go

Dans Go, la gestion des erreurs est une pratique essentielle. Cependant, la gestion de plusieurs erreurs peut conduire à un code verbeux, car chaque erreur nécessite une vérification et une gestion explicites. Cet article examine un exemple artificiel de transfert de texte dans cat et aborde le problème de la gestion efficace de plusieurs erreurs.

Gestion des erreurs dans l'exemple

L'exemple fourni implique l'utilisation de exec.Command pour rediriger les données vers cat et lisez le résultat. Chaque ligne du code d'origine contient trois lignes supplémentaires dédiées à la gestion des erreurs, ce qui entraîne une quantité substantielle de code de gestion des erreurs.

Une approche idiomatique

Nous nous efforçons de gérer les erreurs de manière responsable sans compromettre la lisibilité du code. . Voici une solution idiomatique :

package main

import (
    "fmt"
    "io"
    "io/ioutil"
    "os"
    "os/exec"
)

func piping(input string) (string, error) {
    cmd := exec.Command("cat", "-")
    stdin, err := cmd.StdinPipe()
    if err != nil {
        return "", err
    }
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return "", err
    }
    err = cmd.Start()
    if err != nil {
        return "", err
    }
    _, err = io.WriteString(stdin, input)
    if err != nil {
        return "", err
    }
    err = stdin.Close()
    if err != nil {
        return "", err
    }
    all, err := ioutil.ReadAll(stdout)
    output := string(all)
    if err != nil {
        return output, err
    }
    return output, nil
}

func main() {
    in := "Hello world!"
    fmt.Println(in)
    out, err := piping(in)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    fmt.Println(out)
}

Analyse

Ce code refactorisé utilise la gestion des erreurs de manière plus concise :

  • La fonction de tuyauterie renvoie désormais un tuple contenant la sortie et une erreur le cas échéant.
  • La fonction principale appelle piping et vérifie l'erreur de retour directement.
  • Si une erreur se produit, elle est imprimée sur la console et le programme se termine.

Conclusion

En employant cette approche, nous gérons efficacement plusieurs erreurs sans duplication de code inutile. Cette technique favorise la lisibilité du code et réduit le passe-partout tout en garantissant une gestion appropriée des erreurs.

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!

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn