Comment la gestion des erreurs de Go peut-elle être améliorée pour plus de lisibilité et de concision ?

Gestion des erreurs dans Go

La gestion des erreurs dans Go est un aspect crucial de la programmation. Le langage encourage la vérification et la gestion directe des erreurs, ce qui peut conduire à des erreurs de gestion de code verbeuses de manière répétitive.

Considérez l'exemple artificiel suivant qui canalise "Bonjour tout le monde !" dans cat et lit le résultat :

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
}

Cet exemple contient plusieurs lignes de code de gestion des erreurs pour chaque opération.

Une approche idiomatique dans Go consiste à gérer les erreurs de manière centralisée. Par exemple, nous pouvons encapsuler l'opération de tuyauterie dans une fonction personnalisée qui gère les erreurs en interne :

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

Cette approche réduit la quantité de code de gestion des erreurs dans la fonction principale, la rendant plus concise et plus facile à lire. .

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!