Go adalah bahasa pemrograman populer yang semakin populer karena efektivitas, kecepatan, dan efisiensinya. Namun, kesalahan dapat terjadi selama fase pengembangan dan eksekusi, sama seperti bahasa pemrograman lainnya. Menangani kesalahan secara efektif sangat penting untuk memastikan keandalan dan stabilitas program Go Anda.
Artikel ini akan membahas beberapa metode dan prosedur yang direkomendasikan untuk mengelola kesalahan di Go.
Menangani Kesalahan di Golang
Di Go, Anda bisa menangani kesalahan melalui cara-cara yang disebutkan di bawah ini:
- Fungsi Baru()
- Errorf() Fungsi
- Penanganan kesalahan eksplisit
- Tunda, Panik, dan Pulihkan
- Pembungkus Kesalahan
1: Fungsi Baru()
Bahasa Go menyediakan Baru() berfungsi untuk mengelola kesalahan. Fungsi ini, tersedia dalam paket kesalahan bawaan, memungkinkan pengembang membuat pesan kesalahan khusus untuk program mereka. Dengan memanfaatkan Baru() fungsi, pengembang dapat menangani kesalahan secara efektif dan memberikan pesan kesalahan yang berarti kepada pengguna.
paket utama
impor 'kesalahan'
impor 'fmt'
cek fungsi ( rangkaian nama ) kesalahan {
nKesalahan := kesalahan.Baru ( 'Salah nama' )
jika nama ! = 'Linux' {
kembali kesalahan
}
kembali nol
}
fungsi utama ( ) {
nama := 'Linux'
salah := periksa ( nama )
jika berbuat salah ! = nol {
fmt.Println ( berbuat salah )
} kalau tidak {
fmt.Println ( 'Nama yang sah' )
}
}
Kode di atas menggunakan Baru() checkName berfungsi untuk melihat apakah string Linux sesuai dengan nama yang diberikan. Fungsi menghasilkan kesalahan dengan pesan Salah nama jika namanya tidak Linux . Fungsi mengembalikan nihil untuk menunjukkan bahwa tidak ada kesalahan jika namanya sama dengan Linux .
Variabel nama diatur ke Linux dalam pemanggilan fungsi utama ke checkName fungsi, yang juga menggunakan variabel nama sebagai argumen. Fungsi utama mencetak pesan kesalahan jika checkName fungsi mengembalikan kesalahan. Fungsi utama mencetak Nama yang Sah jika checkName fungsi mengembalikan nol.
Keluaran
2: Fungsi Errorf()
Itu Errorf() fungsi dalam Go memungkinkan kita untuk menangani kesalahan juga. Errorf() memberi kita pilihan untuk memformat pesan kesalahan. Dengan mengimpor paket fmt, pengembang dapat memanfaatkannya untuk menyesuaikan pesan kesalahan agar sesuai dengan kebutuhan mereka. Errorf() merampingkan dan meningkatkan efisiensi pengelolaan dan penyampaian kesalahan di Go.
paket utamaimpor 'fmt'
fungsi div ( n1, n2 kamu ) kesalahan {
jika n2 == 0 {
kembali fmt.Kesalahan ( '%DD \N Tidak Dapat Membagi Angka dengan Nol' , n1, n2 )
}
kembali nol
}
fungsi utama ( ) {
salah := div ( 42 , 0 )
jika berbuat salah ! = nol {
fmt.Cetakf ( 'kesalahan: %s' , salah )
} kalau tidak {
fmt.Println ( 'Divisi yang sah' )
}
}
Pada kode di atas, file div fungsi menerima dua input bilangan bulat, n1, dan n2, dan jika n2 adalah nol, menghasilkan kesalahan. Fungsi menghasilkan kesalahan dengan pesan yang berisi nilai n1 dan n2 jika n2 nol. Fungsi mengembalikan nihil untuk menunjukkan bahwa tidak ada kesalahan jika n2 bukan nol.
Kesalahan yang dikembalikan oleh div disimpan dalam variabel err ketika fungsi utama menjalankan div dengan nilai 42 dan 0. Fungsi utama menggunakan fmt.Printf untuk menampilkan pesan kesalahan jika fungsi div mengembalikan kesalahan. Fungsi utama mencetak Divisi yang sah jika fungsi div mengembalikan nihil.
Keluaran
3: Penanganan Kesalahan Eksplisit
Go mendorong manajemen kesalahan eksplisit dibandingkan dengan bahasa pemrograman lain, yang sering mengandalkan pengecualian. Pendekatan ini mendorong pengembang untuk menggunakan pernyataan if untuk memeriksa kesalahan secara eksplisit, alih-alih mengandalkan blok try-catch. Dengan melakukan ini, kesalahan lebih mungkin ditemukan dan diperbaiki dengan benar. Untuk memfasilitasi ini, Go menyediakan jika salah != nihil pernyataan, yang memungkinkan pengembang untuk memeriksa kesalahan setelah menjalankan suatu fungsi, dan mengambil tindakan yang sesuai berdasarkan hasilnya. Dengan penanganan error yang eksplisit, Go menawarkan pendekatan manajemen error yang lebih terstruktur dan andal.
paket utamaimpor 'fmt'
pembagian fungsi ( a, b mengapung64 ) ( float64, kesalahan ) {
jika b == 0 {
kembali 0 , fmt.Kesalahan ( 'tidak dapat dibagi dengan nol' )
}
kembali A / b, nihil
}
fungsi utama ( ) {
hasilnya, err := bagi ( 13 , 3 )
jika berbuat salah ! = nol {
fmt.Cetakf ( 'Kesalahan: %v \N ' , salah )
} kalau tidak {
fmt.Cetakf ( 'Hasil: %f \N ' , hasil )
}
hasil, err = bagi ( 23 , 0 )
jika berbuat salah ! = nol {
fmt.Cetakf ( 'Kesalahan: %v \N ' , salah )
} kalau tidak {
fmt.Cetakf ( 'Hasil: %f \N ' , hasil )
}
}
Dalam ilustrasi ini, fungsi pembagian digunakan untuk membagi dua nilai. Output adalah hasil dari melakukannya. Jika angka kedua adalah 0, fungsi menghasilkan kesalahan dengan pesan kesalahan yang berbeda.
Pembagian disebut dua kali dalam fungsi utama: sekali dengan input yang valid dan sekali dengan input yang tidak valid. Itu, jika salah != nihil pernyataan digunakan untuk menentukan apakah kesalahan terjadi setiap kali fungsi pembagian digunakan. Pesan kesalahan dicetak jika terjadi. Jika tidak, hasilnya dicetak.
Keluaran
4: Tunda, Panik, dan Pulihkan
Golang juga menyediakan menunda pernyataan, yang digunakan untuk menjalankan fungsi setelah selesainya program atau blok kode tertentu. Itu menunda Pernyataan ini sering digunakan bersamaan dengan pulih berfungsi untuk menangkap dan memulihkan dari kesalahan runtime panik. Ketika kesalahan panik runtime terjadi, file pulih fungsi digunakan untuk memulihkan dari kondisi error dan mencegah program dari crash. Ini berguna untuk tugas pembersihan seperti menutup file, menutup koneksi jaringan, atau melepaskan sumber daya. Dengan menunda tugas ini, Anda memastikan bahwa tugas tersebut dijalankan meskipun terjadi kesalahan.
Itu panik digunakan untuk menghentikan eksekusi normal program ketika terjadi kesalahan yang tidak terduga, sementara pulih digunakan untuk menangani kepanikan dan melanjutkan eksekusi program.
paket utamaimpor 'fmt'
func pulihFromPanic ( ) {
jika r := sembuh ( ) ; R ! = nol {
fmt.Println ( 'Dipulihkan dari kepanikan:' , R )
}
}
pembagian fungsi ( x,y mengambang64 ) float64 {
tunda pemulihanFromPanic ( )
jika dan == 0 {
panik ( 'tidak dapat dibagi dengan nol' )
}
kembali X / Dan
}
fungsi utama ( ) {
fmt.Println ( membagi ( 13 , 3 ) )
fmt.Println ( membagi ( 23 , 0 ) )
}
Pada kode di atas, fungsi bagi digunakan untuk membagi dua nilai floating-point. Output adalah hasil dari melakukannya. Pesan kesalahan yang disesuaikan dikeluarkan oleh fungsi jika angka kedua adalah nol. Pernyataan defer digunakan untuk memanggil pulihDariPanik fungsi. Itu pulihDariPanik fungsi akan mendeteksi kepanikan yang terjadi di dalam fungsi pembagian dan mencetak kesalahan jika itu terjadi.
Pembagian disebut dua kali dalam fungsi utama: sekali dengan input yang valid dan sekali dengan input yang tidak valid. Itu fmt.Println function mencetak output fungsi setiap kali fungsi pembagian dijalankan. Itu pulihDariPanik fungsi akan mendeteksi kepanikan jika itu terjadi dan mencetak kesalahan jika itu terjadi.
Keluaran
Setelah mendeteksi kesalahan, program pulih dari kepanikan dan terus berjalan. Namun, kode tersebut panik dan tidak mengembalikan nilai pada panggilan kedua untuk membagi, itulah sebabnya ia mengembalikan nol.
5: Kesalahan Pembungkusan
Go juga menyertakan fitur yang dikenal sebagai Kesalahan membungkus , yang memungkinkan Anda menambahkan konteks tambahan ke pesan kesalahan. Ini berguna untuk merekam masalah atau memberikan detail lebih lanjut dalam pesan kesalahan. Ini dapat dilakukan dengan membuat jenis kesalahan yang menyematkan kesalahan asli dan konteks tambahan.
paket utamaimpor 'kesalahan'
impor 'fmt'
fungsi utama ( ) {
jika salah := bar ( ) ; berbuat salah ! = nol {
fmt.Println ( berbuat salah )
}
}
pembagian fungsi ( a, b mengapung64 ) ( float64, kesalahan ) {
jika b == 0 {
kembali 0 , kesalahan.Baru ( 'pembagian dengan nol' )
}
kembali A / b, nihil
}
bilah fungsi ( ) ( kesalahan kesalahan ) {
_, err = bagi ( 42 , 0 )
jika berbuat salah ! = nol {
kembali fmt.Kesalahan ( 'gagal menghitung: %w' , salah )
}
kembali nol
}
Dalam kode di atas, fungsi pembagian menghitung rasio dua angka dalam contoh ini dan melontarkan kesalahan jika nilai kedua adalah nol. Fungsi bilah memanggil fungsi bagi dan kemudian membungkus kesalahan itu membagi mengembalikan error baru dengan pesan yang menyertakan pesan error asli menggunakan fungsi fmt.Errorf. Fungsi bilah dipanggil oleh fungsi utama, yang juga mencetak kesalahan apa pun yang dikembalikannya.
Keluaran
Kesimpulan
Pengembangan perangkat lunak harus mencakup penanganan kesalahan , dan Golang memiliki berbagai fungsi dan metode bawaan untuk melakukannya dengan anggun. Mekanisme ini memungkinkan pengembang untuk menangkap dan memulihkan dari kesalahan, mencegah crash program, dan memberikan pesan kesalahan yang informatif kepada pengguna akhir. Dengan menggunakan mekanisme penanganan kesalahan ini secara efektif, pengembang dapat membangun aplikasi perangkat lunak yang tangguh, andal, dan efisien.