Bagaimanakah Go Boleh Mengendalikan Berbilang Ralat dengan Cekap dalam Satu Blok?

Mengendalikan Pelbagai Ralat Secara Elegan dalam Go

Dalam Go, selalunya perlu untuk mengendalikan berbilang ralat sekaligus, terutamanya apabila berurusan dengan I/O operasi atau transformasi data. Walaupun pendekatan tradisional untuk menyemak setiap ralat secara individu boleh membosankan dan berulang, Go menyediakan mekanisme untuk mengendalikan semua ralat dalam satu blok ringkas.

Masalah: Mengendalikan Pelbagai Ralat

Pertimbangkan kod berikut yang cuba menggabungkan berbilang nilai ke dalam JSON:

aJson, err1 := json.Marshal(a)
bJson, err2 := json.Marshal(b)
cJson, err3 := json.Marshal(c)
dJson, err4 := json.Marshal(d)
eJson, err5 := json.Marshal(e)
fJson, err6 := json.Marshal(f)
gJson, err4 := json.Marshal(g)
if err1 != nil {
    return err1
} else if err2 != nil {
    return err2
} else if err3 != nil {
    return err3
} else if err4 != nil {
    return err4
} else if err5 != nil {
    return err5
} else if err5 != nil {
    return err5
} else if err6 != nil {
    return err6
}

Ini kod terdedah kepada ralat dan memerlukan pemeriksaan pengendalian ralat berulang untuk setiap operasi marshaling. Ia juga menjadikan ralat pengendalian untuk semua objek JSON mencabar.

Penyelesaian: Menggunakan Pembolehubah Bukan Tempatan untuk Pengesanan Ralat

Go menyediakan cara yang kemas untuk mengendalikan berbilang ralat dalam satu blok menggunakan pembolehubah bukan tempatan. Berikut ialah versi kod yang dipertingkatkan:

var err error
f := func(dest *D, src S) bool {
    *dest, err = json.Marshal(src)
    return err == nil
}

f(&aJson, a) &&
    f(&bJson, b) &&
    f(&cJson, c) &&
    f(&dJson, d) &&
    f(&eJson, e) &&
    f(&fJson, f) &&
    f(&gJson, g)
return err

Dalam penyelesaian ini, kami mentakrifkan fungsi f yang melaksanakan marshaling dan menetapkan pembolehubah err. Pembolehubah err diisytiharkan di luar fungsi, membolehkan ia dikongsi antara semua panggilan ke fungsi f.

Fungsi f mengambil penunjuk ke objek JSON destinasi dan data sumber. Ia mengembalikan bool yang menunjukkan sama ada marshaling berjaya (tiada ralat berlaku).

Selepas itu, kami memanggil fungsi f untuk setiap objek dan menyambungkan keputusan dengan && (logik dan). Jika mana-mana panggilan kembali palsu (ralat berlaku), rantaian terputus, dan pembolehubah ralat mengandungi ralat pertama yang ditemui. Jika tidak, jika semua panggilan kembali benar, tiada ralat berlaku dan ralat terakhir adalah sifar.

Dalam baris terakhir, kami mengembalikan pembolehubah ralat, yang menahan ralat pertama yang ditemui, atau tiada jika semua operasi berjaya .

Pendekatan ini membolehkan kami mengendalikan semua ralat dalam satu pernyataan, menjadikan pengendalian ralat lebih ringkas dan cekap.

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