Wie kann ich mehrere Fehler in Go effizient behandeln?

Umgang mit mehreren Fehlern in Go

Bei der Fehlerbehandlung in Go liegt der Schwerpunkt auf der expliziten Prüfung von Fehlern dort, wo sie auftreten. Dies kann jedoch zu ausführlichem Code führen, wenn mehrere Fehler in einem einzigen Block behandelt werden.

Betrachten Sie dieses künstliche Beispiel:

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
}

Jede Zeile, die Fehler behandelt, fügt drei zusätzliche Codezeilen hinzu. Viele dieser Fehler sind nicht schwerwiegend oder werden an anderer Stelle behandelt, was zu einer wahrgenommenen Erhöhung der Boilerplate führt.

Idiomatische Fehlerbehandlung

Ein idiomatischer Ansatz besteht darin, Fehler von Funktionen und zurückzugeben Behandeln Sie sie explizit im aufrufenden Code.

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)
}

In diesem Beispiel gibt piping() sowohl die Ausgabe als auch alle aufgetretenen Fehler zurück. Der aufrufende Code kann dann den Fehler behandeln oder ihn bei Bedarf weitergeben.

Fehlerbehandlung in Go

In Go ist eine explizite Fehlerbehandlung unerlässlich. Die expliziten if err != nil-Prüfungen ermutigen Programmierer, Fehler sofort zu behandeln und so unbehandelte Fehler zu vermeiden, die zu unerwartetem Programmverhalten führen könnten.

Während dieser Ansatz in einigen Fällen zu ausführlichem Code führen kann, fördert er einen disziplinierten Ansatz Fehlerbehandlung und Wartbarkeit.

Das obige ist der detaillierte Inhalt vonWie kann ich mehrere Fehler in Go effizient behandeln?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!