Bagaimanakah Saya Boleh Mengendalikan Berbilang Ralat dengan Cekap dalam Go?

Mengendalikan Berbilang Ralat dalam Go

Pengendalian ralat dalam Go menekankan semakan ralat secara eksplisit di mana ia berlaku. Walau bagaimanapun, ini boleh membawa kepada kod verbose apabila mengendalikan berbilang ralat dalam satu blok.

Pertimbangkan contoh rekaan ini:

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
}

Setiap ralat pengendalian baris menambah tiga baris kod tambahan. Kebanyakan ralat ini tidak membawa maut atau dikendalikan di tempat lain, yang membawa kepada peningkatan yang dirasakan dalam boilerplate.

Pengendalian Ralat Idiomatik

Satu pendekatan idiomatik ialah mengembalikan ralat daripada fungsi dan mengendalikannya secara eksplisit dalam kod panggilan.

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

Dalam contoh ini, piping() mengembalikan kedua-dua output dan sebarang ralat yang dihadapi. Kod panggilan kemudiannya boleh mengendalikan ralat atau menyebarkannya jika perlu.

Pengendalian Ralat dalam Go

Dalam Go, pengendalian ralat yang jelas adalah penting. Semakan eksplisit if err != nil menggalakkan pengaturcara mengendalikan ralat dengan serta-merta, mengelakkan ralat tidak dikendalikan yang boleh membawa kepada tingkah laku program yang tidak dijangka.

Walaupun pendekatan ini boleh membawa kepada kod verbose dalam beberapa kes, ia menggalakkan pendekatan berdisiplin untuk pengendalian ralat dan kebolehselenggaraan.

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Mengendalikan Berbilang Ralat dengan Cekap dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!