Golang中的錯誤處理的示例詳解
1、panic
當我們執(zhí)行panic的時候會結束下面的流程：
package main
import "fmt"
func main() {
fmt.Println("hello")
panic("stop")
fmt.Println("world")
}
輸出：
go run 9.go
hello
panic: stop
但是panic也是可以捕獲的，我們可以使用defer和recover實現(xiàn)：
package main
import "fmt"
func main() {
defer func() {
if r := recover(); r != nil {
fmt.Println("recover: ", r)
}
}()
fmt.Println("hello")
panic("stop")
fmt.Println("world")
}
輸出：
go run 9.go
hello
recover: stop
那什么時候適合panic呢？在 Go 中，panic 用于表示真正的異常，例如程序錯誤。我們經(jīng)常會在一些內(nèi)置包里面看到panic的身影。
比如strings.Repeat重復返回一個由字符串 s 的計數(shù)副本組成的新字符串：
func Repeat(s string, count int) string {
if count == 0 {
return ""
}
//
if count < 0 {
panic("strings: negative Repeat count")
} else if len(s)*count/count != len(s) {
panic("strings: Repeat count causes overflow")
}
...
}
我們可以看到當重復的次數(shù)小于0或者重復count次之后s的長度溢出，程序會直接panic，而不是返回錯誤。這時因為strings包限制了error的使用，所以在程序錯誤時會直接panic。
還有一個例子是關于正則表達式的例子：
package main
import (
"fmt"
"regexp"
)
func main() {
pattern := "a[a-z]b*" // 1
compile, err := regexp.Compile(pattern) // 2
if err != nil { // 2
fmt.Println("compile err: ", err)
return
}
// 3
allString := compile.FindAllString("acbcdadb", 3)
fmt.Println(allString)
}
- 編寫一個正則表達式
- 調(diào)用Compile，解析正則表達式，如果成功，返回用于匹配文本的 Regexp 對象。否則返回錯誤
- 利用正則，在輸入的字符串中，獲取所有的匹配字符
可以看到如果上面正則解析失敗是可以繼續(xù)往下執(zhí)行的，但是regexp包中還有另外一個方法MustCompile：
func MustCompile(str string) *Regexp {
regexp, err := Compile(str)
if err != nil {
panic(`regexp: Compile(` + quote(str) + `): ` + err.Error())
}
return regexp
}
這個方法說明正則的解析是強依賴的，如果解析錯誤，直接panic結束程序。用戶可以根據(jù)實際情況選擇。
但是實際開發(fā)中我們還是要謹慎使用panic，因為它會使程序結束運行（除非我們調(diào)用defer recover）
2、包裝錯誤
錯誤包裝是將錯誤包裝或者打包在一個包裝容器中，這樣的話我們就可以追溯到源錯誤。錯誤包裝的主要作用就是：
- 為錯誤添加上下文
- 將錯誤標記為特定類型的錯誤
我們可以看一個訪問數(shù)據(jù)庫的例子：
package main
import (
"fmt"
"github.com/pkg/errors"
)
type Courseware struct {
Id int64
Code string
Name string
}
func getCourseware(id int64) (*Courseware, error) {
courseware, err := getFromDB(id)
if err != nil {
return nil, errors.Wrap(err, "六月的想訪問這個課件") // 2
}
return courseware, nil
}
func getFromDB(id int64) (*Courseware, error) {
return nil, errors.New("permission denied") // 1
}
func main() {
_, err := getCourseware(11)
if err != nil {
fmt.Println(err)
}
}
- 訪問數(shù)據(jù)庫時我們返回了原始的錯誤信息
- 到上層我們添加了一些自定義的上下文信息
輸出：
go run 9.go
六月的想訪問這個課件: permission denied
當然我們也可以將錯誤包裝成我們自定義類型的錯誤，我們稍微修改下上面的例子：
package main
import (
"fmt"
"github.com/pkg/errors"
)
type Courseware struct {
Id int64
Code string
Name string
}
// 1
type ForbiddenError struct {
Err error
}
// 2
func (e *ForbiddenError) Error() string {
return "Forbidden: " + e.Err.Error()
}
func getCourseware(id int64) (*Courseware, error) {
courseware, err := getFromDB(id)
if err != nil {
return nil, &ForbiddenError{err} // 4
}
return courseware, nil
}
func getFromDB(id int64) (*Courseware, error) {
return nil, errors.New("permission denied") // 3
}
func main() {
_, err := getCourseware(11)
if err != nil {
fmt.Println(err)
}
}
- 首先我們自定義了ForbiddenError的錯誤類型
- 我們實現(xiàn)了error接口
- 訪問數(shù)據(jù)庫拋出原始錯誤
- 上層返回ForbiddenError類型的錯誤
輸出：
go run 9.go
Forbidden: permission denied
當然我們也可以不用創(chuàng)建自定義錯誤的類型，去包裝錯誤添加上下文：
package main
import (
"fmt"
"github.com/pkg/errors"
)
type Courseware struct {
Id int64
Code string
Name string
}
func getCourseware(id int64) (*Courseware, error) {
courseware, err := getFromDB(id)
if err != nil {
return nil, fmt.Errorf("another wrap err: %w", err) // 1
}
return courseware, nil
}
func getFromDB(id int64) (*Courseware, error) {
return nil, errors.New("permission denied")
}
func main() {
_, err := getCourseware(11)
if err != nil {
fmt.Println(err)
}
}
使用%w包裝錯誤
使用這的好處是我們可以追溯到源錯誤，從而方便我們做一些特殊的處理。
還有一種方式是使用：
return nil, fmt.Errorf("another wrap err: %v", err)
%v的方式不會包裝錯誤，所以無法追溯到源錯誤，但往往有時候我們會選擇這種方式，而不用%w的方式。%w的方式雖然能包裝源錯誤，但往往我們會通過源錯誤去做一些處理，假如源錯誤被修改，那包裝這個源錯誤的相關錯誤都需要做響應變化。
3、錯誤類型判斷
我們擴展一下上面查詢課件的例子。現(xiàn)在我們有這樣的判斷，如果傳進來的id不合法我們返回400錯誤，如果查詢數(shù)據(jù)庫報錯我們返回500錯誤，我們可以像下面這樣寫：
package main
import (
"fmt"
"github.com/pkg/errors"
)
type Courseware struct {
Id int64
Code string
Name string
}
type ForbiddenError struct {
Err error
}
func (e *ForbiddenError) Error() string {
return "Forbidden: " + e.Err.Error()
}
func getCourseware(id int64) (*Courseware, error) {
if id <= 0 {
return nil, fmt.Errorf("invalid id: %d", id)
}
courseware, err := getFromDB(id)
if err != nil {
return nil, &ForbiddenError{err}
}
return courseware, nil
}
func getFromDB(id int64) (*Courseware, error) {
return nil, errors.New("permission denied")
}
func main() {
_, err := getCourseware(500) // 我們可以修改這里的id看下打印的結構
if err != nil {
switch err := err.(type) {
case *ForbiddenError:
fmt.Println("500 err: ", err)
default:
fmt.Println("400 err: ", err)
}
}
}
輸出：
go run 9.go
500 err: Forbidden: permission denied
這樣看起來好像也沒什么問題，現(xiàn)在我們稍微修改下代碼，把上面ForbiddenError包裝一下：
package main
import (
"fmt"
"github.com/pkg/errors"
)
type Courseware struct {
Id int64
Code string
Name string
}
type ForbiddenError struct {
Err error
}
func (e *ForbiddenError) Error() string {
return "Forbidden: " + e.Err.Error()
}
func getCourseware(id int64) (*Courseware, error) {
if id <= 0 {
return nil, fmt.Errorf("invalid id: %d", id)
}
courseware, err := getFromDB(id)
if err != nil {
return nil, fmt.Errorf("wrap err: %w", &ForbiddenError{err}) // 這里包裝了一層錯誤
}
return courseware, nil
}
func getFromDB(id int64) (*Courseware, error) {
return nil, errors.New("permission denied")
}
func main() {
_, err := getCourseware(500)
if err != nil {
switch err := err.(type) {
case *ForbiddenError:
fmt.Println("500 err: ", err)
default:
fmt.Println("400 err: ", err)
}
}
}
輸出：
go run 9.go
400 err: wrap err: Forbidden: permission denied
可以看到我們的Forbidden錯誤進到了400里面，這并不是我們想要的結果。之所以會這樣，是因為在ForbiddenError的外面又包裝了一層Error錯誤，使用類型斷言的時候判斷出來的是Error錯誤，所以進到了400分支。
這里我們可以使用errors.As方法，它會遞歸調(diào)用Unwrap方法，找到錯誤鏈中第一個與target匹配的方法：
package main
import (
"fmt"
"github.com/pkg/errors"
)
type Courseware struct {
Id int64
Code string
Name string
}
type ForbiddenError struct {
Err error
}
func (e *ForbiddenError) Error() string {
return "Forbidden: " + e.Err.Error()
}
func getCourseware(id int64) (*Courseware, error) {
if id <= 0 {
return nil, fmt.Errorf("invalid id: %d", id)
}
courseware, err := getFromDB(id)
if err != nil {
return nil, fmt.Errorf("wrap err: %w", &ForbiddenError{err})
}
return courseware, nil
}
func getFromDB(id int64) (*Courseware, error) {
return nil, errors.New("permission denied")
}
func main() {
_, err := getCourseware(500)
if err != nil {
var f *ForbiddenError // 這里實現(xiàn)了*ForbiddenError接口，不然會panic
if errors.As(err, &f) { // 找到匹配的錯誤
fmt.Println("500 err: ", err)
} else {
fmt.Println("400 err: ", err)
}
}
}
輸出：
go run 9.go
500 err: wrap err: Forbidden: permission denied
4、錯誤值判斷
在代碼中或者mysql庫或者io庫中我們經(jīng)常會看到這樣的全局錯誤：
var ErrCourseware = errors.New("courseware")
這種錯誤我們稱之為哨兵錯誤。一般數(shù)據(jù)庫沒查到ErrNoRows或者io讀到了EOF錯誤，這些特定的錯誤可以幫助我們做一些特殊的處理。
一般我們會直接用==號判斷錯誤值，但是就像上面的如果錯誤被包裝哪我們就不好去判斷了。好在errors包中提供了errors.Is方法，通過遞歸調(diào)用Unwrap判斷錯誤鏈中是否與目標錯誤相匹配的錯誤值：
if err != nil {
if errors.Is(err, ErrCourseware) {
// ...
} else {
// ...
}
}到此這篇關于Golang中的錯誤處理的示例詳解的文章就介紹到這了,更多相關Golang錯誤處理內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要介紹了Go語言按字節(jié)截取字符串的方法,涉及Go語言操作字符串的技巧,非常具有實用價值,需要的朋友可以參考下2015-02-02
如果某個G執(zhí)行時間過長，其他的G如何才能被正常調(diào)度，這就引出了接下來的話題：協(xié)作與搶占。本文將通過一些示例為大家詳細講講調(diào)度器中協(xié)作與搶占的相關知識，需要的可以參考一下2023-04-04
這篇文章主要為大家介紹了Golang?官方依賴注入工具wire示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-10-10
大家都知道排序有內(nèi)部排序和外部排序，內(nèi)部排序是數(shù)據(jù)記錄在內(nèi)存中進行排序，而外部排序是因排序的數(shù)據(jù)很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。下面就來詳細介紹golang的基本類型排序與slice排序，有需要的朋友們可以參考借鑒。2016-09-09
在?Golang?的?Web?項目中,自定義?recovery?中間件是一種常見的做法,用于捕獲并處理應用程序的運行時錯誤,下面我們就來看看具體如何實現(xiàn)吧2023-09-09
這篇文章主要為大家詳細介紹了Golang實現(xiàn)斷點續(xù)傳、復制文件功能，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-07-07
這篇文章主要給大家介紹了關于Go語言中定時器cron使用的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧。2018-01-01
這篇文章主要介紹了Golang使用Redis與連接池方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-06-06
這篇文章主要為大家詳細介紹了如何通過Golang實現(xiàn)一個簡易的命令行功能，文中的示例代碼講解詳細，具有一定的學習價值，感興趣的可以了解一下2023-02-02
這篇文章主要為大家介紹了go語法入門any類型的使用場景示例詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2023-09-09