Ang Go ay isang sikat na programming language na naging popular dahil sa pagiging epektibo, bilis, at kahusayan nito. Gayunpaman, ang mga pagkakamali ay maaaring mangyari sa panahon ng mga yugto ng pagbuo at pagpapatupad, tulad ng anumang iba pang programming language. Ang epektibong paghawak ng mga error ay mahalaga upang matiyak ang pagiging maaasahan at katatagan ng iyong mga Go program.
Susuriin ng artikulong ito ang ilang paraan at inirerekomendang mga pamamaraan para sa pamamahala ng mga error sa Go.
Pangasiwaan ang Mga Error sa Golang
Sa Go, kaya mo hawakan ang mga error sa pamamagitan ng mga nabanggit na pamamaraan sa ibaba:
- New() Function
- Errorf() Function
- Tahasang paghawak ng error
- Ipagpaliban, Panic, at Bumawi
- Error sa Pag-wrap
1: New() Function
Ang wikang Go ay nagbibigay ng Bago() function upang pamahalaan ang mga error. Ang function na ito, na magagamit sa built-in na pakete ng mga error, ay nagbibigay-daan sa mga developer na lumikha ng mga custom na mensahe ng error para sa kanilang mga programa. Sa pamamagitan ng paggamit ng Bago() function, mabisang mapangasiwaan ng mga developer ang mga error at makapagbigay ng mga makabuluhang mensahe ng error sa mga user.
pangunahing pakete
angkat 'mga pagkakamali'
angkat 'fmt'
func check ( string ng pangalan ) pagkakamali {
nError := errors.Bago ( 'Hindi wastong pangalan' )
kung pangalan ! = 'Linux' {
bumalik nError
}
bumalik wala
}
func main ( ) {
pangalan:= 'Linux'
err := suriin ( pangalan )
kung magkamali ! = wala {
fmt.Println ( magkamali )
} iba pa {
fmt.Println ( 'Bagong Pangalan' )
}
}
Ang code sa itaas ay gumagamit ng Bago() checkName function upang makita kung ang string Linux tumutugma sa pangalang ibinigay. Ang function ay gumagawa ng isang error sa mensahe Hindi wastong pangalan kung ang pangalan ay hindi Linux . Ang function ay nagbabalik ng nil upang ipakita na walang error kung ang pangalan ay katumbas ng Linux .
Ang variable ng pangalan ay nakatakda sa Linux sa tawag ng pangunahing function sa checkName function, na kumukuha din ng variable ng pangalan bilang argumento. Ang pangunahing function ay nagpi-print ng mensahe ng error kung ang checkName function ay nagbabalik ng isang error. Ang pangunahing function ay nagpi-print ng Wastong Pangalan kung ang checkName function ay nagbabalik ng wala.
Output
2: Errorf() Function
Ang Errorf() Ang function sa Go ay nagbibigay-daan sa amin na pangasiwaan din ang mga error. Errorf() nagbibigay sa amin ng opsyong i-format ang mensahe ng error. Sa pamamagitan ng pag-import ng fmt package, magagamit ito ng mga developer upang i-customize ang mga mensahe ng error upang umangkop sa kanilang mga pangangailangan. Errorf() pinapadali at pinapahusay ang kahusayan ng pamamahala at paghahatid ng mga error sa Go.
pangunahing paketeangkat 'fmt'
func div ( n1, n2 ikaw ) pagkakamali {
kung n2 == 0 {
bumalik fmt.Errorf ( '%DD \n Hindi mahati ang isang Numero sa zero' , n1, n2 )
}
bumalik wala
}
func main ( ) {
mali := div ( 42 , 0 )
kung magkamali ! = wala {
fmt.Printf ( 'error: %s' , mali )
} iba pa {
fmt.Println ( 'Bagong Dibisyon' )
}
}
Sa code sa itaas, ang div tumatanggap ang function ng dalawang integer input, n1, at n2, at kung zero ang n2, nagdudulot ito ng error. Ang function ay gumagawa ng isang error na may isang mensahe na naglalaman ng mga halaga ng n1 at n2 kung ang n2 ay zero. Ang function ay nagbabalik ng nil upang ipakita na walang error kung ang n2 ay hindi zero.
Ang error na ibinabalik ng div ay nai-save sa err variable kapag ang pangunahing function ay nagpapatakbo ng div na may mga halagang 42 at 0. Ang pangunahing function ay gumagamit ng fmt.Printf upang ipakita ang mensahe ng error kung ang div function ay nagbabalik ng isang error. Ang pangunahing function ay nagpi-print Wastong Dibisyon kung ang div function ay nagbabalik ng nil.
Output
3: Tahasang Paghawak ng Error
Hinihikayat ni Go ang tahasang pamamahala ng error kumpara sa iba pang mga programming language, na madalas na umaasa sa mga exception. Hinihikayat ng diskarteng ito ang mga developer na gamitin ang mga pahayag na tahasang suriin kung may mga error, sa halip na umasa sa mga bloke ng try-catch. Sa paggawa nito, ang mga error ay mas malamang na matagpuan at maayos na nalutas. Upang mapadali ito, ibinibigay ni Go ang kung mali!= wala statement, na nagpapahintulot sa mga developer na suriin ang mga error pagkatapos magsagawa ng isang function, at magsagawa ng mga naaangkop na aksyon batay sa resulta. Sa tahasang paghawak ng error, nag-aalok ang Go ng mas structured at maaasahang diskarte sa pamamahala ng error.
pangunahing paketeangkat 'fmt'
func divide ( a, b lumutang64 ) ( float64, error ) {
kung b == 0 {
bumalik 0 , fmt.Errorf ( 'hindi maaaring hatiin sa zero' )
}
bumalik a / b, wala
}
func main ( ) {
resulta, err := hatiin ( 13 , 3 )
kung magkamali ! = wala {
fmt.Printf ( 'Error: %v \n ' , mali )
} iba pa {
fmt.Printf ( 'Resulta: %f \n ' , resulta )
}
resulta, err = hatiin ( 23 , 0 )
kung magkamali ! = wala {
fmt.Printf ( 'Error: %v \n ' , mali )
} iba pa {
fmt.Printf ( 'Resulta: %f \n ' , resulta )
}
}
Sa paglalarawang ito, ang divide function ay ginagamit upang hatiin ang dalawang halaga. Ang output ay ang kinalabasan ng paggawa nito. Kung ang pangalawang numero ay 0, ang function ay gumagawa ng isang error na may natatanging mensahe ng error.
Ang paghahati ay tinatawag na dalawang beses sa pangunahing function: isang beses na may wastong mga input at isang beses na may hindi wastong input. Ang, kung err!= wala Ang pahayag ay ginagamit upang matukoy kung ang isang error ay naganap sa bawat oras na ang division function ay ginagamit. Ang isang mensahe ng error ay naka-print kung may nangyari. Kung hindi, ang kinalabasan ay naka-print.
Output
4: Ipagpaliban, Panic, at Pagbawi
Nagbibigay din si Golang ng iliban statement, na ginagamit upang magsagawa ng isang function pagkatapos ng pagkumpleto ng isang programa o isang partikular na bloke ng code. Ang iliban ang pahayag ay kadalasang ginagamit kasabay ng gumaling function upang mahuli at mabawi mula sa runtime panic error. Kapag nangyari ang isang runtime panic error, ang gumaling Ang function ay ginagamit upang mabawi mula sa kondisyon ng error at maiwasan ang pag-crash ng program. Ito ay kapaki-pakinabang para sa mga gawain sa paglilinis tulad ng pagsasara ng mga file, pagsasara ng mga koneksyon sa network, o paglabas ng mga mapagkukunan. Sa pamamagitan ng pagpapaliban sa mga gawaing ito, tinitiyak mong maipapatupad ang mga ito kahit na may naganap na error.
Ang panic ay ginagamit upang ihinto ang normal na pagpapatupad ng programa kapag ang isang hindi inaasahang error ay nangyari, habang gumaling ay ginagamit upang mahawakan ang gulat at ipagpatuloy ang pagpapatupad ng programa.
pangunahing paketeangkat 'fmt'
function na recoverFromPanic ( ) {
kung r := mabawi ( ) ; r ! = wala {
fmt.Println ( 'Nabawi mula sa gulat:' , r )
}
}
func divide ( x,y lumutang64 ) lumutang64 {
ipagpaliban ang recoverFromPanic ( )
kung at == 0 {
panic ( 'hindi maaaring hatiin sa zero' )
}
bumalik x / at
}
func main ( ) {
fmt.Println ( hatiin ( 13 , 3 ) )
fmt.Println ( hatiin ( 23 , 0 ) )
}
Sa code sa itaas, ang divide function ay ginagamit upang hatiin ang dalawang floating-point value. Ang output ay ang kinalabasan ng paggawa nito. Ang isang naka-customize na mensahe ng error ay output ng function kung ang pangalawang numero ay zero. Ang defer statement ay ginagamit upang i-invoke ang recoverFromPanic function. Ang recoverFromPanic Ang function ay makaka-detect ng panic na nangyari sa loob ng division function at mag-print ng error kung nangyari ito.
Ang paghahati ay tinatawag na dalawang beses sa pangunahing function: isang beses na may wastong mga input at isang beses na may hindi wastong input. Ang fmt.Println Ang function ay nagpi-print ng output ng function sa tuwing tatakbo ang division function. Ang recoverFromPanic ang function ay makaka-detect ng panic kung mangyari ito at mag-print ng error kung nangyari ito.
Output
Matapos makita ang error, nakabawi ang programa mula sa pagkasindak at patuloy na tumatakbo. Gayunpaman, nag-panic ang code at hindi nagbalik ng halaga sa pangalawang tawag para hatiin, kaya naman nagbalik ito ng zero.
5: Error sa Pag-wrap
Kasama rin sa Go ang isang feature na kilala bilang Error sa pambalot , na nagbibigay-daan sa iyong magdagdag ng karagdagang konteksto sa isang mensahe ng error. Ito ay kapaki-pakinabang para sa pag-record ng mga problema o pagbibigay ng karagdagang mga detalye sa mga mensahe ng error. Magagawa ito sa pamamagitan ng paggawa ng uri ng error na nag-embed ng orihinal na error at karagdagang konteksto.
pangunahing paketeangkat 'mga pagkakamali'
angkat 'fmt'
func main ( ) {
kung mali := bar ( ) ; magkamali ! = wala {
fmt.Println ( magkamali )
}
}
func divide ( a, b lumutang64 ) ( float64, error ) {
kung b == 0 {
bumalik 0 , mga error.Bago ( 'dibisyon ng zero' )
}
bumalik a / b, wala
}
func bar ( ) ( mali mali ) {
_, err = hatiin ( 42 , 0 )
kung magkamali ! = wala {
bumalik fmt.Errorf ( 'hindi nakalkula: %w' , mali )
}
bumalik wala
}
Sa code sa itaas, kinakalkula ng divide function ang ratio ng dalawang numero sa halimbawang ito at naglalabas ng error kung zero ang pangalawang value. Tinatawag ng bar function ang divide function at pagkatapos ay binabalot ang error na iyon hatiin babalik sa isang bagong error na may mensaheng kasama ang orihinal na mensahe ng error gamit ang fmt.Errorf function. Ang function ng bar ay tinatawag ng pangunahing function, na nagpi-print din ng anumang mga error na ibinabalik nito.
Output
Konklusyon
Dapat kasama ang software development maling paghawak , at ang Golang ay may iba't ibang mga built-in na function at pamamaraan para sa paggawa nito nang maganda. Ang mga mekanismong ito ay nagbibigay-daan sa mga developer na mahuli at makabawi mula sa mga error, maiwasan ang mga pag-crash ng program, at magbigay ng impormasyon ng mga mensahe ng error sa mga end user. Sa pamamagitan ng epektibong paggamit sa mga mekanismong ito sa paghawak ng error, ang mga developer ay makakabuo ng matatag, maaasahan, at mahusay na software application.