Go — популярный язык программирования, популярность которого выросла благодаря его эффективности, скорости и эффективности. Однако ошибки могут возникать на этапах разработки и выполнения, как и в случае с любым другим языком программирования. Эффективная обработка ошибок необходима для обеспечения надежности и стабильности ваших программ Go.
В этой статье будут рассмотрены несколько методов и рекомендуемых процедур для управления ошибками в Go.
Обработка ошибок в Golang
В Го можно обрабатывать ошибки нижеуказанными методами:
- Новая() Функция
- Функция Errorf()
- Явная обработка ошибок
- Отсрочка, паника и восстановление
- Обтекание ошибок
1: Функция 'Новый()'
Язык Go обеспечивает Новый() функция управления ошибками. Эта функция, доступная во встроенном пакете ошибок, позволяет разработчикам создавать собственные сообщения об ошибках для своих программ. Используя Новый() Функция позволяет разработчикам эффективно обрабатывать ошибки и предоставлять пользователям содержательные сообщения об ошибках.
основной пакет
Импортировать 'ошибки'
Импортировать 'ФМТ'
функциональная проверка ( строка имени ) ошибка {
nError := ошибки. Новый ( 'Неверное имя' )
если имя ! '=' 'Линукс' {
возвращаться ошибка
}
возвращаться ноль
}
основная функция ( ) {
имя := 'Линукс'
ошибся := проверить ( имя )
если ошибаться ! = ноль {
fmt.Println ( ошибаться )
} еще {
fmt.Println ( 'Действительное имя' )
}
}
В приведенном выше коде используется Новый() checkName функция, чтобы увидеть, является ли строка линукс соответствует указанному имени. Функция выдает ошибку с сообщением Неверное имя если имя не линукс . Функция возвращает nil, чтобы показать, что ошибки не было, если имя равно линукс .
Переменная name устанавливается в линукс в вызове основной функции checkName функция, которая также принимает переменную имени в качестве аргумента. Основная функция печатает сообщение об ошибке, если checkName функция возвращает ошибку. Основная функция печатает Действительное имя если checkName функция возвращает ноль.
Выход
2: Функция Errorf()
Ошибкаf() Функция в Go также позволяет нам обрабатывать ошибки. Ошибкаf() дает нам возможность отформатировать сообщение об ошибке. Импортируя пакет fmt, разработчики могут использовать его для настройки сообщений об ошибках в соответствии со своими потребностями. Ошибкаf() упрощает и повышает эффективность управления и передачи ошибок в Go.
основной пакетИмпортировать 'ФМТ'
функция div ( п1, п2 ты ) ошибка {
если п2 == 0 {
возвращаться fmt.Errorf ( '%д / %д \n Невозможно разделить число на ноль' , n1, n2 )
}
возвращаться ноль
}
основная функция ( ) {
ошибка := дел ( 42 , 0 )
если ошибаться ! = ноль {
fmt.Printf ( 'ошибка: %s' , ошибаюсь )
} еще {
fmt.Println ( «Действительный отдел» )
}
}
В приведенном выше коде див Функция принимает два целых числа, n1 и n2, и если n2 равно нулю, она выдает ошибку. Функция выдает ошибку с сообщением, содержащим значения n1 и n2, если n2 равно нулю. Функция возвращает nil, чтобы показать, что ошибки не было, если n2 не равно нулю.
Ошибка, которую возвращает div, сохраняется в переменной err, когда основная функция запускает div со значениями 42 и 0. Основная функция использует fmt.Printf для отображения сообщения об ошибке, если функция div возвращает ошибку. Основная функция печатает Действительный отдел если функция div возвращает nil.
Выход
3: Явная обработка ошибок
Go поощряет явное управление ошибками по сравнению с другими языками программирования, которые часто полагаются на исключения. Этот подход побуждает разработчиков использовать операторы if для явной проверки ошибок, вместо того чтобы полагаться на блоки try-catch. Таким образом, вероятность обнаружения ошибок и их надлежащего исправления повышается. Чтобы облегчить это, Go предоставляет если ошибся != ноль оператор, который позволяет разработчикам проверять наличие ошибок после выполнения функции и предпринимать соответствующие действия в зависимости от результата. Благодаря явной обработке ошибок Go предлагает более структурированный и надежный подход к управлению ошибками.
основной пакетИмпортировать 'ФМТ'
функция деления ( а, б с плавающей запятой64 ) ( float64, ошибка ) {
если б == 0 {
возвращаться 0 , fmt.Errorf ( 'на ноль делить нельзя' )
}
возвращаться а / б, ноль
}
основная функция ( ) {
результат, ошибка := разделить ( 13 , 3 )
если ошибаться ! = ноль {
fmt.Printf ( 'Ошибка: %v \n ' , ошибаюсь )
} еще {
fmt.Printf ( 'Результат: %f \n ' , результат )
}
результат, ошибка = разделить ( 23 , 0 )
если ошибаться ! = ноль {
fmt.Printf ( 'Ошибка: %v \n ' , ошибаюсь )
} еще {
fmt.Printf ( 'Результат: %f \n ' , результат )
}
}
На этом рисунке функция деления используется для деления двух значений. Выход - это результат этого. Если второе число равно 0, функция выдает ошибку с отчетливым сообщением об ошибке.
Разделение вызывается дважды в основной функции: один раз с допустимыми входными данными и один раз с недопустимыми входными данными. Если ошибка != ноль оператор используется для определения того, имела ли место ошибка каждый раз, когда используется функция деления. При возникновении ошибки печатается сообщение об ошибке. Если нет, результат печатается.
Выход
4. Откладывать, паниковать и восстанавливаться
Golang также предоставляет откладывать оператор, который используется для выполнения функции после завершения программы или определенного блока кода. откладывать утверждение часто используется в сочетании с восстанавливаться функция для обнаружения и восстановления после ошибок паники во время выполнения. При возникновении паники во время выполнения восстанавливаться Функция используется для восстановления после состояния ошибки и предотвращения сбоя программы. Это полезно для задач очистки, таких как закрытие файлов, закрытие сетевых подключений или освобождение ресурсов. Откладывая эти задачи, вы гарантируете их выполнение даже в случае возникновения ошибки.
паника используется для остановки нормального выполнения программы при возникновении непредвиденной ошибки, в то время как восстанавливаться используется для обработки паники и продолжения выполнения программы.
основной пакетИмпортировать 'ФМТ'
функция восстановления из паники ( ) {
если г := восстановить ( ) ; р ! = ноль {
fmt.Println ( 'Оправился от паники:' , р )
}
}
функция деления ( х, у с плавающей запятой64 ) поплавок64 {
отложить восстановлениеFromPanic ( )
если и == 0 {
паника ( 'на ноль делить нельзя' )
}
возвращаться Икс / и
}
основная функция ( ) {
fmt.Println ( разделять ( 13 , 3 ) )
fmt.Println ( разделять ( 23 , 0 ) )
}
В приведенном выше коде функция деления используется для деления двух значений с плавающей запятой. Выход - это результат этого. Пользовательское сообщение об ошибке выводится функцией, если второе число равно нулю. Оператор defer используется для вызова восстановитьFromPanic функция. восстановитьFromPanic функция обнаружит панику, которая произошла внутри функции деления, и выведет ошибку, если это произошло.
Разделение вызывается дважды в основной функции: один раз с допустимыми входными данными и один раз с недопустимыми входными данными. fmt.Println Функция печатает вывод функции каждый раз, когда запускается функция деления. восстановитьFromPanic Функция обнаружит панику, если она произойдет, и выведет ошибку, если это произойдет.
Выход
После обнаружения ошибки программа вышла из паники и продолжила работу. Однако код запаниковал и не вернул значение при втором вызове деления, поэтому и вернул ноль.
5: упаковка ошибок
Go также включает функцию, известную как Упаковка ошибок , что позволяет добавить дополнительный контекст к сообщению об ошибке. Это полезно для записи проблем или предоставления дополнительных сведений в сообщениях об ошибках. Этого можно добиться путем создания типа ошибки, включающего в себя исходную ошибку и дополнительный контекст.
основной пакетИмпортировать 'ошибки'
Импортировать 'ФМТ'
основная функция ( ) {
если ошибка := бар ( ) ; ошибаться ! = ноль {
fmt.Println ( ошибаться )
}
}
функция деления ( а, б с плавающей запятой64 ) ( float64, ошибка ) {
если б == 0 {
возвращаться 0 , ошибки.Новый ( 'деление на ноль' )
}
возвращаться а / б, ноль
}
функциональная панель ( ) ( ошибка ошибка ) {
_, ошибка = разделить ( 42 , 0 )
если ошибаться ! = ноль {
возвращаться fmt.Errorf ( 'не удалось рассчитать: %w' , ошибаюсь )
}
возвращаться ноль
}
В приведенном выше коде функция деления вычисляет отношение двух чисел в этом примере и выдает ошибку, если второе значение равно нулю. Функция bar вызывает функцию разделения, а затем оборачивает ошибку, которая разделять возвращает новую ошибку с сообщением, которое включает исходное сообщение об ошибке с помощью функции fmt.Errorf. Функция bar вызывается основной функцией, которая также выводит все возвращаемые ею ошибки.
Выход
Заключение
Разработка программного обеспечения должна включать обработка ошибок , а в Golang есть различные встроенные функции и методы, позволяющие сделать это изящно. Эти механизмы позволяют разработчикам обнаруживать ошибки и устранять их, предотвращать сбои программ и предоставлять информативные сообщения об ошибках конечным пользователям. Эффективно используя эти механизмы обработки ошибок, разработчики могут создавать надежные, надежные и эффективные программные приложения.