Comment puis-je gérer efficacement plusieurs erreurs dans Go ?

Gestion de plusieurs erreurs dans Go

La gestion des erreurs dans Go met l'accent sur la vérification explicite des erreurs là où elles se produisent. Cependant, cela peut conduire à un code verbeux lors de la gestion de plusieurs erreurs dans un seul bloc.

Considérez cet exemple artificiel :

package main

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

func main() {
    cmd := exec.Command("cat", "-")
    stdin, err := cmd.StdinPipe()
    if err != nil {
        return
    }
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return
    }
    err = cmd.Start()
    if err != nil {
        return
    }
    _, err = io.WriteString(stdin, "Hello world!")
    if err != nil {
        return
    }
    err = stdin.Close()
    if err != nil {
        return
    }
    output, err := ioutil.ReadAll(stdout)
    if err != nil {
        return
    }
    fmt.Println(string(output))
    return
}

Chaque ligne de gestion des erreurs ajoute trois lignes de code supplémentaires. Beaucoup de ces erreurs ne sont pas fatales ou traitées ailleurs, ce qui conduit à une augmentation perçue du passe-partout.

Gestion des erreurs idiomatiques

Une approche idiomatique consiste à renvoyer les erreurs des fonctions et gérez-les explicitement dans le code appelant.

package main

import (
    "fmt"
    "os"

    "errors"
)

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
    }
    if err = cmd.Start(); err != nil {
        return "", err
    }
    if _, err = io.WriteString(stdin, input); err != nil {
        return "", err
    }
    if err = stdin.Close(); err != nil {
        return "", err
    }
    all, err := ioutil.ReadAll(stdout)
    if err != nil {
        return "", err
    }
    return string(all), 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)
}

Dans cet exemple, piping() renvoie à la fois la sortie et toute erreur rencontrée. Le code appelant peut alors gérer l'erreur ou la propager si nécessaire.

Gestion des erreurs dans Go

Dans Go, la gestion explicite des erreurs est essentielle. Les vérifications explicites if err != nil encouragent les programmeurs à gérer les erreurs immédiatement, évitant ainsi les erreurs non gérées qui pourraient conduire à un comportement inattendu du programme.

Bien que cette approche puisse conduire à un code verbeux dans certains cas, elle favorise une approche disciplinée de gestion des erreurs et maintenabilité.

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!