Pengendalian ralat dalam Go: Cara menulis kod pengendalian ralat yang baik

Tidak kira bahasa pengaturcaraan yang anda gunakan, pengendalian ralat adalah bahagian penting. Dalam bahasa Go, terdapat mekanisme pengendalian ralat yang baik yang boleh membantu pengaturcara menangani ralat dan pengecualian dengan mudah. Artikel ini akan memberi tumpuan kepada cara menulis kod pengendalian ralat yang sangat baik untuk meningkatkan kualiti kod dan kestabilan program.

1. Pengetahuan asas pengendalian ralat

Dalam bahasa Go, ralat dianggap sebagai nilai biasa, yang boleh diproses dan diluluskan. Setiap fungsi mungkin mengembalikan nilai jenis ralat Jika ralat berlaku, ia akan mengembalikan nilai ralat bukan sifar, jika tidak ia akan mengembalikan sifar.

Jenis ralat dalam bahasa Go ialah ralat jenis antara muka terbina dalam, yang hanya mempunyai satu kaedah:

antara muka ralat taip {

Error() string

}

Antara muka ini Ralat kaedah () ditakrifkan, yang mengembalikan rentetan yang menunjukkan maklumat ralat.

Oleh itu, kita boleh menggunakan if err != nil untuk menentukan sama ada ralat berlaku Jika ralat berlaku, kita boleh mengendalikannya mengikut situasi tertentu. Dalam keadaan biasa, kami akan menggunakan pakej log untuk mengeluarkan maklumat log, mengembalikan maklumat ralat kepada pemanggil peringkat atas atau mengambil langkah tambahan untuk mengelakkan ralat daripada berulang.

2. Amalan terbaik untuk pengendalian ralat

2.1 Kembalikan maklumat ralat yang jelas

Mekanisme pengendalian ralat yang baik dalam bahasa Go boleh memberikan pengguna lebih banyak maklumat Clear mesej ralat membantu mereka mencari masalah dengan cepat. Oleh itu, semasa menulis program Go, sebaiknya berikan maklumat ralat yang jelas untuk setiap ralat supaya pengguna dapat mencari dan menyelesaikan masalah dengan cepat.

Contohnya:

jika _, err := os.Open(filePath != nil {

return fmt.Errorf("failed to open file %s: %v", filePath, err)

}

Dalam perkara di atas kod , menggunakan fmt.Errorf() untuk membalut mesej ralat, memberikan mesej ralat yang jelas: ralat berlaku semasa membuka fail, termasuk nama fail dan mesej ralat tertentu.

2.2 Apabila anda tidak memerlukan jenis ralat tertentu, gunakan ralat.New() untuk mencipta ralat

Dalam bahasa Go, sangat mudah untuk menggunakan ralat.New() untuk mencipta kesilapan. Jika kami perlu mengembalikan ralat yang tidak mengandungi maklumat khusus, kami boleh menggunakan ralat.New() untuk mencipta ralat baharu.

Contohnya:

mengembalikan ralat.Baru("sesuatu yang tidak kena")

2.3 Elakkan ralat bersarang

Apabila mengendalikan ralat, anda mungkin menghadapi To kes ralat bersarang, iaitu satu ralat boleh membawa kepada ralat yang lebih besar. Pada masa ini, kita perlu mengendalikan ralat dengan berhati-hati untuk mengelakkan ralat bersarang.

Salah satu cara untuk mengelakkan ralat bersarang ialah memisahkan fungsi yang ralat bersarang mungkin berlaku kepada fungsi lain yang mengendalikan semua ralat.

Contohnya:

func doSomething() ralat {

if _, err := os.Open(filePath); err != nil {
    return fmt.Errorf("failed to open file %s: %v", filePath, err)
}
// do something
return nil

}

func main() {

if err := doSomething(); err != nil {
    log.Fatalf("failed to do something: %v", err)
}

}

Dalam kod di atas, kami menguraikan fungsi doSomething() di mana ralat mungkin berlaku kepada dua fungsi, mengelakkan masalah ralat bersarang dan menjadikan kod lebih jelas dan lebih mudah difahami.

2.4 Apabila ralat berlaku pada berbilang baris, gunakan koma bertitik untuk memisahkannya

Dalam bahasa Go, ralat biasanya menduduki berbilang baris Pada masa ini, koma bertitik harus digunakan untuk memisahkan ralat untuk membuatnya jelas dan mudah dibaca.

Contohnya:

jika nilai < nilai minValue >

return fmt.Errorf(
    "value %d is out of range [%d, %d]; %s",
    value, minValue, maxValue, errAdditionalInfo)

}

Dalam kod di atas, kami menggunakan titik koma. Ralat berbilang baris dipisahkan untuk menjadikan mesej ralat lebih jelas dan mudah dibaca.

Panik dan pulih dalam bahasa Go

Selain mekanisme pengendalian ralat di atas, bahasa Go juga menyediakan mekanisme panik dan pemulihan untuk mengendalikan ralat yang serius dan prosedur Pemulihan.

Apabila ralat tidak dapat dipulihkan berlaku dalam atur cara, anda boleh menggunakan fungsi panik() untuk membuang pengecualian. Pada masa ini, program akan segera menghentikan pelaksanaan dan mencetak mesej ralat.

Contohnya:

func doSomething() {

if _, err := os.Open(filePath); err != nil {
    panic(fmt.Sprintf("failed to open file %s: %v", filePath, err))
}
// do something

}

Dalam kod di atas, jika ralat berlaku semasa membuka fail, atur cara akan berhenti serta-merta Laksanakan dan buang pengecualian.

Sebaliknya, fungsi recover() boleh menyambung semula pelaksanaan program selepas panik program. Fungsi recover() hanya boleh digunakan dalam fungsi defer, yang digunakan untuk menangkap panik dan menghentikan panik daripada berlalu ke lapisan luar.

Contohnya:

func main() {

defer func() {
    if err := recover(); err != nil {
        log.Fatalf("recover from panic: %v", err)
    }
}()
doSomething()

}

Dalam kod di atas, kami menggunakan fungsi defer plus recover() untuk memulihkan pelaksanaan program. Apabila program panik, fungsi recover() akan dipanggil dalam fungsi tangguh untuk menangkap maklumat ralat panik dan mencetak.

Ringkasan

Pengendalian ralat yang cemerlang ialah tanda kualiti kod dan boleh menjadikan kod lebih mantap dan selamat. Dalam bahasa Go, mekanisme pengendalian ralat yang baik boleh mengendalikan dan melepasi ralat dengan mudah, dan fungsi panik dan memulihkan boleh digunakan untuk mengendalikan ralat yang serius dan menyambung semula pelaksanaan program. Untuk menulis kod pengendalian ralat yang baik, kita perlu mengikuti amalan terbaik dan sentiasa memberi perhatian kepada kejelasan dan kejelasan mesej ralat.

Atas ialah kandungan terperinci Pengendalian ralat dalam Go: Cara menulis kod pengendalian ralat yang baik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!