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

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!