golang開發:Error的使用

飛翔碼農發表於2021-07-20
GolangError

Error是Go語言開發中最基礎也是最重要的部分，跟其他語言的try catch的作用基本一致，想想在PHP JAVA開發中，try catch 不會使用，或者使用不靈活，就無法感知到程式執行中出現了什麼錯誤，是特別可怕的一件事。

Error 基礎

Golang中 error型別就是一個最基本interface，定義了一個Error()的方法

type error interface {
	Error() string
}

平常使用最多的是這樣的

errors.New("error")

在Golang中errors.New這樣定義的

func New(text string) error {
	return &errorString{text}
}

// errorString is a trivial implementation of error.
type errorString struct {
	s string
}

func (e *errorString) Error() string {
	return e.s
}

其實是返回了一個errorString的結構體，這個結構體實現了Error()方法，所以實現了error interface

看下Error在專案開發中是怎麼使用的？

1.定義Error變數

在一段程式碼裡面可能返回了很多個error，我怎麼判斷這個error是哪一種呢？
是這樣的吧

var ERR_MSG = "error"
if err.Error() == ERR_MSG

這樣的話，多個第三方類庫和自己專案的錯誤描述要是一致的話就無法比較出來了，其實不應該是這樣的。
我們看下 beego裡面orm是怎麼定義的，從上面的基礎我們知道errors.New返回的是errorString的指標

var (
	ErrTxHasBegan    = errors.New("<Ormer.Begin> transaction already begin")
	ErrTxDone        = errors.New("<Ormer.Commit/Rollback> transaction not begin")
	ErrMultiRows     = errors.New("<QuerySeter> return multi rows")
	ErrNoRows        = errors.New("<QuerySeter> no row found")
	ErrStmtClosed    = errors.New("<QuerySeter> stmt already closed")
	ErrArgs          = errors.New("<Ormer> args error may be empty")
	ErrNotImplement  = errors.New("have not implement")
)

其實都是使用指標判斷的

看下怎麼使用，下面是虛擬碼

err := this.QueryTable(this.table).Filter("id", id).One(data)
if err != nil && err != orm.ErrNoRows {
	return err
}
return nil

這種其實在Golang 原始碼或者第三方類庫裡面用的比較多，缺點就是耦合，呼叫者使用一個第三方類庫，需要知道的它的程式碼裡面的錯誤型別，而且還需要在專案中使用這些錯誤型別的變數進行比較，第一次使用的開發者，很難想到需要這麼使用。

2.自定義自己的Error

以前PHP的專案Exception裡面會定義自己的錯誤碼 code。
Golang中我們也可以定義自己的Error型別，然後使用斷言決定是那種Error來獲取更多的錯誤資料，看下下面的示例程式碼，瞭解下自定義Error的簡單使用

type SelfError struct {
	Code int
	Err error
}

func (this *SelfError) Error() string {
	return this.Err.Error()
}
func (this *SelfError) GetCode() int {
	return this.Code
}

func OpenFile(name string) error {
	err := os.Rename("/tmp/test","/tmp/test1")
	if err != nil {
		return &SelfError{-1001, err}
	}
	return nil
}

func main() {
	err := OpenFile("test")
	switch erro := err.(type) {
	case nil:
		fmt.Println("success")
	case *SelfError:
		fmt.Println(erro.Error(),erro.Code)
	case error:
		fmt.Println(erro.Error())
	}
}

還有一種用法就是判斷error型別是否是自定義如果是，就返回自定義的屬性

func main() {
	err := OpenFile("test")
	serr, ok := err.(*SelfError)
	if ok {
		fmt.Println(serr.GetCode())
	}
}

可以看到都是通過斷言去判斷error是否是自定義的Error，如果是，就使用自定義的Error自己的屬性和方法。

耦合，呼叫者需要使用switch或者斷言才能使用自定義的Error的屬性。

3.Wrap Errors的使用

wrap errors的使用應該是專案對error的處理運用最多的一種，可以方便的加入使用時的上下文。
Wrap Errors 顧名思義就是把error一層層的包裝，最外層拿到的是error的一個堆疊資訊，根據堆疊資訊一直可以追蹤到第一個引起error 的呼叫程式碼。
需要使用這個包

github.com/pkg/errors

看下程式碼示例

package main

import (
	"fmt"
	"github.com/pkg/errors"
	"os"
)

func ModelFile() error {
	err := os.Rename("/tmp/test","/tmp/test1")
	if err != nil {
		return errors.Wrap(err, "model_rename_fail")
	}
	return nil
}

func LogicFile() error {
	err := ModelFile()
	if err != nil {
		return errors.Wrap(err, "logic_rename_fail")
	}
	return nil
}

func main() {
	err := LogicFile()
	if err != nil {
		fmt.Printf("error:%v", errors.Cause(err))
		fmt.Printf("%+v", err)
	}
}

看下執行結果的堆疊

error:rename /tmp/test /tmp/test1: no such file or directoryrename /tmp/test /tmp/test1: no such file or directory
model_rename_fail
main.ModelFile
        /data/www/go/src/test1/main.go:12
main.LogicFile
        /data/www/go/src/test1/main.go:18
main.main
        /data/www/go/src/test1/main.go:26
runtime.main
        /usr/local/go/src/runtime/proc.go:203
runtime.goexit
        /usr/local/go/src/runtime/asm_amd64.s:1357
logic_rename_fail
main.LogicFile
        /data/www/go/src/test1/main.go:20
main.main
        /data/www/go/src/test1/main.go:26
runtime.main
        /usr/local/go/src/runtime/proc.go:203
runtime.goexit
        /usr/local/go/src/runtime/asm_amd64.s:1357

使用的簡單規則

這麼多使用方法，到底應該用哪一種，大致建議應該是這樣的

  1. 需要做比較錯誤型別的時候，肯定是第一種方式使用，目前也沒有更好的方式
  2. 需要加入自己專案的錯誤碼或者複雜的一些上下文，可能就需要使用第二種自定義錯誤型別
  3. 需要依賴第三方的類庫，這個類庫可能也不太穩定，那麼wrap error優勢就比較明顯，可以列印記錄堆疊，方便定位。
  4. 一些常用的簡單專案，就只需在觸發錯誤的地方記錄上下文打上日誌，直接返回error就可以了，這是最簡單最方便的。

相關文章