Go е харесван език за програмиране, който нарасна в популярност поради своята ефективност, скорост и ефикасност. Въпреки това, грешки могат да се случат по време на фазите на разработка и изпълнение, точно както при всеки друг език за програмиране. Ефективното боравене с грешки е от съществено значение за гарантиране на надеждността и стабилността на вашите Go програми.
Тази статия ще разгледа няколко метода и препоръчителни процедури за управление на грешки в Go.
Обработка на грешки в Golang
В Go можете обработка на грешки чрез посочените по-долу методи:
- Функция New().
- Функция Errorf().
- Изрично обработване на грешки
- Отлагане, паника и възстановяване
- Грешка при обвиване
1: Функция New().
Езикът Go предоставя ново() функция за управление на грешки. Тази функция, налична във вградения пакет за грешки, позволява на разработчиците да създават персонализирани съобщения за грешки за своите програми. Чрез използване на ново() функция, разработчиците могат да обработват грешките ефективно и да предоставят смислени съобщения за грешки на потребителите.
основен пакет
импортиране 'грешки'
импортиране 'fmt'
функционална проверка ( име низ ) грешка {
nError := грешки. Ново ( „Невалидно име“ )
ако име ! = 'Линукс' {
връщане nГрешка
}
връщане нула
}
основна функция ( ) {
име := 'Линукс'
грешка := проверка ( име )
ако грешка ! = нула {
fmt.Println ( грешка )
} друго {
fmt.Println ( „Валидно име“ )
}
}
Горният код използва ново() checkName функция, за да видите дали низът Linux съвпада с даденото име. Функцията генерира грешка със съобщението Невалидно име ако името не е Linux . Функцията връща нула, за да покаже, че няма грешка, ако името е равно на Linux .
Променливата име е зададена на Linux в извикването на основната функция към checkName функция, която също приема променливата име като аргумент. Основната функция отпечатва съобщението за грешка, ако checkName функция връща грешка. Основната функция отпечатва Валидно име ако checkName функцията връща нула.
Изход
2: Функция Errorf().
The Errorf() функция в Go ни позволява да обработваме и грешки. Errorf() ни дава възможност да форматираме съобщението за грешка. Като импортират пакета fmt, разработчиците могат да го използват, за да персонализират съобщенията за грешки, за да отговарят на техните нужди. Errorf() рационализира и подобрява ефективността на управлението и предаването на грешки в Go.
основен пакетимпортиране 'fmt'
func div ( n1, n2 ти ) грешка {
ако n2 == 0 {
връщане fmt.Errorf ( „%d / %d \н Не може да се раздели число на нула' , n1, n2 )
}
връщане нула
}
основна функция ( ) {
грешка := div ( 42 , 0 )
ако грешка ! = нула {
fmt.Printf ( 'грешка: %s' , грешка )
} друго {
fmt.Println ( „Валидно деление“ )
}
}
В горния код, див функцията приема две цели числа, n1 и n2, и ако n2 е нула, генерира грешка. Функцията генерира грешка със съобщение, което съдържа стойностите на n1 и n2, ако n2 е нула. Функцията връща нула, за да покаже, че няма грешка, ако n2 не е нула.
Грешката, която div връща, се записва в променливата err, когато основната функция изпълни div със стойности 42 и 0. Основната функция използва fmt.Printf, за да покаже съобщението за грешка, ако функцията div върне грешка. Основната функция отпечатва Валидно деление ако функцията div върне нула.
Изход
3: Изрична обработка на грешки
Go насърчава явното управление на грешки в сравнение с други езици за програмиране, които често разчитат на изключения. Този подход насърчава разработчиците да използват оператори if за изрична проверка за грешки, вместо да разчитат на блокове try-catch. Правейки това, има по-голяма вероятност грешките да бъдат открити и правилно отстранени. За да улесни това, Go предоставя if err != нула оператор, който позволява на разработчиците да проверяват за грешки след изпълнение на функция и да предприемат подходящи действия въз основа на резултата. С изрично обработване на грешки, Go предлага по-структуриран и надежден подход за управление на грешки.
основен пакетимпортиране 'fmt'
функция разделяне ( a, b float64 ) ( float64, грешка ) {
ако b == 0 {
връщане 0 , fmt.Errorf ( 'не може да се дели на нула' )
}
връщане а / b, нула
}
основна функция ( ) {
резултат, грешка := разделяне ( 13 , 3 )
ако грешка ! = нула {
fmt.Printf ( „Грешка: %v \н ' , грешка )
} друго {
fmt.Printf ( „Резултат: %f \н ' , резултат )
}
резултат, грешка = разделяне ( 23 , 0 )
ако грешка ! = нула {
fmt.Printf ( „Грешка: %v \н ' , грешка )
} друго {
fmt.Printf ( „Резултат: %f \н ' , резултат )
}
}
В тази илюстрация функцията за разделяне се използва за разделяне на две стойности. Резултатът е резултатът от това. Ако второто число е 0, функцията генерира грешка с ясно съобщение за грешка.
Divide се извиква два пъти в основната функция: веднъж с валидни входни данни и веднъж с невалиден вход. The, if грешка != нула изразът се използва за определяне дали е възникнала грешка всеки път, когато се използва функцията за деление. Ако се появи, се отпечатва съобщение за грешка. Ако не, резултатът се отпечатва.
Изход
4: Отлагане, паника и възстановяване
Golang също така предоставя отлагам оператор, който се използва за изпълнение на функция след завършване на програма или конкретен блок от код. The отлагам твърдението често се използва във връзка с възстанови се функция за улавяне и възстановяване от паник грешки по време на изпълнение. Когато възникне паник грешка по време на изпълнение, възстанови се се използва за възстановяване от състоянието на грешка и предотвратяване на срив на програмата. Това е полезно за задачи за почистване, като затваряне на файлове, затваряне на мрежови връзки или освобождаване на ресурси. Чрез отлагането на тези задачи вие гарантирате, че те ще бъдат изпълнени дори ако възникне грешка.
The паника се използва за спиране на нормалното изпълнение на програмата, когато възникне неочаквана грешка, докато възстанови се се използва за справяне с паниката и продължаване на изпълнението на програмата.
основен пакетимпортиране 'fmt'
func recoverFromPanic ( ) {
ако r := възстановяване ( ) ; r ! = нула {
fmt.Println ( „Възстановен от паниката:“ , r )
}
}
функция разделяне ( x,y float64 ) float64 {
отложи recoverFromPanic ( )
ако и == 0 {
паника ( 'не може да се дели на нула' )
}
връщане х / и
}
основна функция ( ) {
fmt.Println ( разделям ( 13 , 3 ) )
fmt.Println ( разделям ( 23 , 0 ) )
}
В горния код функцията за разделяне се използва за разделяне на две стойности с плаваща запетая. Резултатът е резултатът от това. Функцията извежда персонализирано съобщение за грешка, ако второто число е нула. Инструкцията defer се използва за извикване на recoverFromPanic функция. The recoverFromPanic функцията ще открие паника, възникнала във функцията за разделяне, и ще отпечата грешка, ако се е случила.
Divide се извиква два пъти в основната функция: веднъж с валидни входни данни и веднъж с невалиден вход. The fmt.Println функцията отпечатва изхода на функцията всеки път, когато се изпълнява функцията за деление. The recoverFromPanic функцията ще открие паника, ако се случи, и ще отпечата грешка, ако се случи.
Изход
След откриване на грешката, програмата се възстанови от паниката и продължи да работи. Кодът обаче се паникьоса и не върна стойност при второто извикване за разделяне, поради което върна нула.
5: Обвиване на грешки
Go също включва функция, известна като Грешка при обвиване , което ви позволява да добавите допълнителен контекст към съобщение за грешка. Това е полезно за записване на проблеми или предоставяне на допълнителни подробности в съобщения за грешка. Това може да се постигне чрез създаване на тип грешка, който вгражда оригиналната грешка и допълнителен контекст.
основен пакетимпортиране 'грешки'
импортиране 'fmt'
основна функция ( ) {
ако грешка := лента ( ) ; грешка ! = нула {
fmt.Println ( грешка )
}
}
функция разделяне ( a, b float64 ) ( float64, грешка ) {
ако b == 0 {
връщане 0 , грешки.Нов ( 'деление на нула' )
}
връщане а / b, нула
}
функционална лента ( ) ( грешка грешка ) {
_, грешка = разделяне ( 42 , 0 )
ако грешка ! = нула {
връщане fmt.Errorf ( 'неуспешно изчисляване: %w' , грешка )
}
връщане нула
}
В горния код функцията за деление изчислява съотношението на две числа в този пример и извежда грешка, ако втората стойност е нула. Бар функцията извиква функцията за разделяне и след това обвива грешката, която разделям връща нова грешка със съобщение, което включва оригиналното съобщение за грешка, използвайки функцията fmt.Errorf. Функцията bar се извиква от основната функция, която също отпечатва всички грешки, които връща.
Изход
Заключение
Разработката на софтуер трябва да включва обработка на грешки , а Golang има различни вградени функции и методи за това елегантно. Тези механизми позволяват на разработчиците да улавят и възстановяват грешки, да предотвратяват сривове на програмата и да предоставят информативни съобщения за грешки на крайните потребители. Използвайки ефективно тези механизми за обработка на грешки, разработчиците могат да създават стабилни, надеждни и ефективни софтуерни приложения.