Wie kann die Fehlerbehandlung von Go im Hinblick auf Lesbarkeit und Prägnanz verbessert werden?

Fehlerbehandlung in Go

Die Fehlerbehandlung in Go ist ein entscheidender Aspekt der Programmierung. Die Sprache fördert die direkte Fehlerprüfung und -behandlung, was zu wiederholten Fehlern bei der Behandlung von ausführlichem Code führen kann.

Betrachten Sie das folgende künstliche Beispiel, das „Hallo Welt!“ weiterleitet. in cat und liest die Ausgabe:

package main

import "fmt"
import "io"
import "io/ioutil"
import "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
}

Dieses Beispiel enthält mehrere Zeilen Fehlerbehandlungscode für jede Operation.

Ein idiomatischer Ansatz in Go besteht darin, Fehler zentral zu behandeln. Beispielsweise können wir den Piping-Vorgang in einer benutzerdefinierten Funktion kapseln, die Fehler intern verwaltet:

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

Dieser Ansatz reduziert die Menge an Fehlerbehandlungscode in der Hauptfunktion und macht sie prägnanter und leichter lesbar .

Das obige ist der detaillierte Inhalt vonWie kann die Fehlerbehandlung von Go im Hinblick auf Lesbarkeit und Prägnanz verbessert werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!