Adakah Go menyediakan cara standard atau de facto untuk mengendalikan ralat dalam satu pernyataan (iaitu pengendalian ralat sebaris)?

Adakah bahasa Go menyediakan cara standard atau de facto untuk mengendalikan ralat dalam satu kenyataan, iaitu pengendalian ralat sebaris? Ini adalah soalan yang sering ditanya oleh ramai pemula bahasa Go. Jawapannya ya, bahasa Go menyediakan cara yang ringkas dan berkesan untuk menangani ralat dalam satu kenyataan. Dalam bahasa Go, anda boleh menggunakan borang pengisytiharan pendek pernyataan if, digabungkan dengan ciri nilai berbilang pulangan bagi fungsi, untuk melaksanakan pengendalian ralat sebaris. Pendekatan ini ringkas dan fleksibel, serta boleh meningkatkan kebolehbacaan dan kebolehselenggaraan kod. Pada masa yang sama, bahasa Go juga menyediakan beberapa fungsi perpustakaan standard dan fungsi pengendalian ralat untuk mengendalikan senario ralat yang lebih kompleks. Secara keseluruhannya, bahasa Go menyediakan kaedah yang lengkap dan mudah digunakan untuk mengendalikan ralat dalam satu kenyataan.

Kandungan soalan

Dalam Rust, Result 类型可以被认为是 Go 中的 (val, err) 模式，可以在它出现的语句中立即“展开”，并且不需要专用多行的复杂性到这个任务。例如，假设我们有一个函数 foo mengembalikan nombor atau ralat. Dalam Rust, pengendalian ralat ini (tanpa mengabaikannya) boleh semudah:

let x = foo().unwrap() + 1;

Dalam Go, pendekatan yang disyorkan nampaknya:

x, err := Foo()
if err != nil {
    panic(err)
}
x = x + 1

Adakah Go menyediakan cara standard untuk mengendalikan ralat dengan segera dalam satu kenyataan seperti yang Rust lakukan? Atau adakah saya perlu menggunakan penyelesaian tempatan?

Penyelesaian sementara saya ialah:

func unwrap[T any](val T, err error) T {
    if err != nil {
        panic(err)
    } else {
        return val
    }
}

Saya agak terkejut dengan kesederhanaan yang berlebihan. Tiada satu pun daripada lima soalan yang dipautkan adalah pendua, dan tiada satu pun daripadanya secara khusus menjawab soalan saya. Sesetengah mungkin kelihatan tidak berkaitan sama sekali. Saya rasa ini kerana tajuk saya tersalah kata. Saya telah menyusun semula tajuk itu agar lebih relevan dengan masalah sebenar saya. Syukurlah, u/norbjd menjawab soalan saya dengan secukupnya.

Penyelesaian

Seperti yang @mkopriva katakan dalam ulasan, tiada cara terbina dalam untuk melakukan ini dalam Go. Walau bagaimanapun, anda boleh menemui corak ini di banyak perpustakaan di bawah nama Must:

• di text/template 中：必须
• di regexp 中：必须编译
• di net/netip 中：MustParseAddr
• Tunggu

Terdapat cadangan awam pada Pergi untuk menambah kaedah must.Do am, tetapi belum ada kandungan konkrit lagi.

Pendekatan yang disyorkan pada masa ini ialah menggunakan generik untuk mentakrifkan Must kaedah dalam kod anda (mulai Go 1.18), seperti yang anda lakukan:

func Must[T any](v T, err error) T {
    if err != nil {
        panic(err)
    }
    return v
}

dan gunakannya seperti ini:

import (
    "errors"
    "fmt"
)

func Foo() (int, error) {
    return 1, nil
}

func Bar() (int, error) {
    return 0, errors.New("some error")
}

func main() {
    foo := Must(Foo())
    fmt.Println(foo)
    bar := Must(Bar()) // this will panic with "some error"
    fmt.Println(bar)
}

Terdapat percubaan untuk mencipta perpustakaan untuk menyediakan kaedah ini, seperti wingyplus/must, tetapi seperti yang ditunjukkan oleh repo, berdasarkan falsafah Go:

Jadi, anda boleh menentukan kaedah anda sendiri dalam setiap projek, atau gunakan jenis perpustakaan ini sehingga Must disepadukan ke dalam perpustakaan standard Go (jika ada).

Atas ialah kandungan terperinci Adakah Go menyediakan cara standard atau de facto untuk mengendalikan ralat dalam satu pernyataan (iaitu pengendalian ralat sebaris)?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!