Go语言基础之异常&错误

1. 异常处理

Golang中对于一般的错误处理提供了error接口，对于不可预见的错误,也就是只会在程序运行时异常被抛出来。处理提供了两个内置函数panic和recover。panic和recover类似于java中的try/catch/throw。

panic

当在一个函数执行过程中调用panic()函数时，正常的函数执行流程将立即终止，但函数中之前使用defer关键字延迟执行的语句将正常展开执行，之后该函数将返回到调用函数，并导致逐层向上执行panic流程，直至所属的goroutine中所有正在执行的函数被终止。错误信息将被报告，包括在调用panic()函数时传入的参数，这个过程称为异常处理流程。

panic 是在程序执行期间突然遇到，未经处理的异常。 在 Go 中，panc 不是处理程序中异常的理想方式。 建议使用 error 对象。 发生 panic 时，程序执行停止。 panic 之后要继续执行的程序就使用 defer。

  • 停止当前程序的执行

  • 一直向上返回，执行每一层的defer

  • 如果没有遇到recover， 程序退出

recover

recover函数用于终止错误处理流程。一般情况下，recover应该在一个使用defer关键字的函数中执行以有效截取错误处理流程。如果没有在发生异常的goroutine中明确调用恢复过程（调用recover函数），会导致该goroutine所属的进程打印异常信息后直接退出。

对于第三方库的调用，在不清楚是否有panic的情况下，最好在适配层统一加上recover过程，否则会导致当前进程的异常退出，而这并不是我们所期望的。

简单的实现如下：

func test(){
	defer func() {
		if err:=recover();err!=nil{ //err不等于零值，说明发生了异常
			fmt.Println("err=",err)
			fmt.Println("发生错误我要做什么处理")
		}
	}()
	i:=10
	n:=0
	m:=i/n  //错误，除数不能为0
	fmt.Println(m)
}
func main() {
	test()
	fmt.Println("main函数")
}

注意:

  1. 利用recover处理panic指令，defer 必须放在 panic 之前定义，另外 recover 只有在 defer 调用的函数中才有效。否则当panic时，recover无法捕获到panic，无法防止panic扩散。
  2. recover 处理异常后，逻辑并不会恢复到 panic 那个点去，函数跑到 defer 之后的那个点。
  3. 多个 defer 会形成 defer 栈，后定义的 defer 语句会被最先调用。

规则

同步执行

在panic发生的方法的祖辈层都能处理

package main

import (
	"fmt"
	"time"
)

func haha1() int {
	a:= []int{1,2,3}
	return a[3]
}
func hehe()  {
    // 放在main中也行
	defer func() {
		if  err:=recover();err!=nil{
			fmt.Println("异常处理")
		}
	}()
	haha1()
}

func main() {
	hehe()
	time.Sleep(time.Second)
}

异步执行

必须得在被go 的方法中

package main

import (
	"fmt"
	"time"
)

func haha1() int {
	a:= []int{1,2,3}
	return a[3]
}
func hehe()  {
	defer func() {
		if  err:=recover();err!=nil{
			fmt.Println("异常处理")
		}
	}()
	haha1()
}

func main() {
	go hehe()
	time.Sleep(time.Second)
}

小结：

  • 仅在defer 调用中使用
  • 获取panic的值
  • 如果无法处理，可重新panic

2. Error

error类型其实是一个接口类型，也是一个 Go 语言的内建类型。在这个接口类型的声明中只包含了一个方法Error。Error方法不接受任何参数，但是会返回一个string类型的结果。它的作用是返回错误信息的字符串表示形式。

接口Error()

error其实一个接口，内置的，我们看下它的定义

// The error built-in interface type is the conventional interface for
// representing an error condition, with the nil value representing no error.
type error interface {
    Error() string
}

它只有一个方法 Error，只要实现了这个方法，就是实现了error。现在我们自己定义一个错误试试。

type fileError struct {
}

func (fe *fileError) Error() string {
    return "文件错误"
}
package main

import (
	"fmt"
	"os"
)

type fileError struct {
	err error
	message string
}

func (f fileError)Error() string{
	return f.err.Error() + f.message
}

func main() {
	file, err := os.Open("demo.txt")
	if err!= nil {
		err = fileError{err:err, message:"文件打开失败"}
		fmt.Println(err)
	}
    defer file.Close()
}

fmt.Errorf

通过fmt.Errorf函数，基于已经存在的err再生成一个新的newErr，然后附加上我们想添加的文本信息。这种办法比较方便，但是问题也很明显，我们丢失了原来的err，因为它已经被我们的fmt.Errorf函数转成一个新的字符串了。

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.Open("demo.txt")
	if err!= nil {
		err = fmt.Errorf("文件打开失败：%v", err)
		fmt.Println(err)
	}
    defer file.Close()
}

errors.New

package main

import (
	"errors"
	"fmt"
	"os"
)

type fileError struct {
	err error
	message string
}

func (f fileError)Error() string{
	return f.err.Error()+f.message
}

func main() {
	file, err := os.Open("demo.txt")
	if err!= nil {
		err = errors.New("文件打开失败:" + err.Error())
		fmt.Println(err)
	}
    defer file.Close()
}

Wrapping Error（Error包装）

可以一个error嵌套另一个error功能，好处就是我们可以根据嵌套的error序列，生成一个error错误跟踪链，也可以理解为错误堆栈信息，这样可以便于我们跟踪调试，哪些错误引起了什么问题，根本的问题原因在哪里。

因为error可以嵌套，所以每次嵌套的时候，我们都可以提供新的错误信息，并且保留原来的error。现在我们看下如何生成一个嵌套的error。

方式一：fmt.Errorf

Golang并没有提供什么Wrap函数，而是扩展了fmt.Errorf函数，加了一个%w来生成一个可以Wrapping Error,通过这种方式，我们可以创建一个个以Wrapping Error。

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.Open("demo.txt")
	if err!= nil {
		e := fmt.Errorf("文件打开失败:%w",err)
		fmt.Println(e)
	}
    defer file.Close()
}

原理

func Errorf(format string, a ...interface{}) error {
	p := newPrinter()
	p.wrapErrs = true
	p.doPrintf(format, a)
	s := string(p.buf)
	var err error
	if p.wrappedErr == nil {
		err = errors.New(s)
	} else {
		err = &wrapError{s, p.wrappedErr}
	}
	p.free()
	return err
}

方式二：自定义 struct

type WarpError struct {
    msg string
    err error
}

func (e *WarpError) Error() string {
    return e.msg
}

func (e *WrapError) Unwrap() error {
    return e.err
}

之前看过源码的同学可能已经知道了，这就是 fmt/errors.go 中关于 warp 的结构。
就，很简单。自定义一个实现了 Unwrap 方法的 struct 就可以了。

Unwrap 函数

拆开一个被包装的 error

Golang 1.13引入了wrapping error后，同时为errors包添加了3个工具函数，他们分别是Unwrap、Is和As，先来聊聊Unwrap。

顾名思义，它的功能就是为了获得被嵌套的error。

func main() {
    e := errors.New("原始错误e")
    w := fmt.Errorf("Wrap了一个错误%w", e)
    fmt.Println(errors.Unwrap(w))
}

以上这个例子，通过errors.Unwrap(w)后，返回的其实是个e，也就是被嵌套的那个error。

这里需要注意的是，嵌套可以有很多层，我们调用一次errors.Unwrap函数只能返回最外面的一层error，如果想获取更里面的，需要调用多次errors.Unwrap函数。最终如果一个error不是warpping error，那么返回的是nil。

func Unwrap(err error) error {
    //先判断是否是wrapping error
    u, ok := err.(interface {
        Unwrap() error
    })
    //如果不是，返回nil
    if !ok {
        return nil
    }
    //否则则调用该error的Unwrap方法返回被嵌套的error
    return u.Unwrap()
}

Is 函数

在Go 1.13之前没有wrapping error的时候，我们要判断error是不是同一个error可以使用如下办法：

if err == os.ErrExist

这样我们就可以通过判断来做一些事情。但是现在有了wrapping error后这样办法就不完美的，因为你根本不知道返回的这个err是不是一个嵌套的error,嵌套了几层。所以基于这种情况，Golang为我们提供了errors.Is函数。

当多层调用返回的错误被一次次地包装起来，我们在调用链上游拿到的错误如何判断是否是底层的某个错误呢？
它递归调用 Unwrap 并判断每一层的 err 是否相等，如果有任何一层 err 和传入的目标错误相等，则返回 true。

func Is(err, target error) bool
  1. 如果err和target是同一个，那么返回true
  2. 如果err 是一个wrap error,target也包含在这个嵌套error链中的话，那么也返回true。

很简单的一个函数，要么咱俩相等，要么err包含target，这两种情况都返回true，其余返回false。

func Is(err, target error) bool {
    if target == nil {
        return err == target
    }
    isComparable := reflectlite.TypeOf(target).Comparable()
    //for循环，把err一层层剥开，一个个比较，找到就返回true
    for {
        if isComparable && err == target {
            return true
        }
        //这里意味着你可以自定义error的Is方法，实现自己的比较代码
        if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
            return true
        }
        //剥开一层，返回被嵌套的err
        if err = Unwrap(err); err == nil {
            return false
        }
    }
}

Is函数源代码如上，其实就是一层层反嵌套，剥开然后一个个的和target比较，相等就返回true。

As 函数

在Go 1.13之前没有wrapping error的时候，我们要把error转为另外一个error，一般都是使用type assertion 或者 type switch，其实也就是类型断言。

if perr, ok := err.(*os.PathError); ok {
    fmt.Println(perr.Path)
}

比如例子中的这种方式，但是现在给你返回的err可能是已经被嵌套了，甚至好几层了，这种方式就不能用了，所以Golang为我们在errors包里提供了As函数，现在我们把上面的例子，用As函数实现一下。

var perr *os.PathError
if errors.As(err, &perr) {
    fmt.Println(perr.Path)
}

这个和上面的 errors.Is 大体上是一样的，区别在于 Is 是严格判断相等，即两个 error 是否相等。
而As则是判断类型是否相同，并提取第一个符合目标类型的错误，用来统一处理某一类错误。

这样就可以了，就可以完全实现类型断言的功能，而且还更强大，因为它可以处理wrapping error。

func As(err error, target interface{}) bool

从功能上来看，As所做的就是遍历err嵌套链，从里面找到类型符合的error，然后把这个error赋予target,这样我们就可以使用转换后的target了，这里有值得赋予，所以target必须是一个指针。

func As(err error, target interface{}) bool {
    //一些判断，保证target，这里是不能为nil
    if target == nil {
        panic("errors: target cannot be nil")
    }
    val := reflectlite.ValueOf(target)
    typ := val.Type()
    //这里确保target必须是一个非nil指针
    if typ.Kind() != reflectlite.Ptr || val.IsNil() {
        panic("errors: target must be a non-nil pointer")
    }
    //这里确保target是一个接口或者实现了error接口
    if e := typ.Elem(); e.Kind() != reflectlite.Interface && !e.Implements(errorType) {
        panic("errors: *target must be interface or implement error")
    }
    targetType := typ.Elem()
    for err != nil {
        //关键部分，反射判断是否可被赋予，如果可以就赋值并且返回true
        //本质上，就是类型断言，这是反射的写法
        if reflectlite.TypeOf(err).AssignableTo(targetType) {
            val.Elem().Set(reflectlite.ValueOf(err))
            return true
        }
        //这里意味着你可以自定义error的As方法，实现自己的类型断言代码
        if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target) {
            return true
        }
        //这里是遍历error链的关键，不停的Unwrap，一层层的获取err
        err = Unwrap(err)
    }
    return false
}

自定义错误

func read(str string) (err error){
    if str!="aaa"{
        return errors.New("传的值不等于aaa！")//自定义异常
    }else {
        return nil
    }
}

func test1()  {
    err :=read("aaa")
    if err!=nil{
        panic(err)//err!=nil说明发生了异常，用panic()输出异常并终止程序
    }
    fmt.Println("test1函数继续执行")
}

func main() {
    test1()
    fmt.Println("main函数继续执行")
}

3. 总结

设计特征：

  1. 在编译时，会检查预编译错误，存在错误时编译器将抛出到标准输出，并修改程序。
  2. 在程序运行期间产生的错误（如数组访问越界、空指针引用等）：
  • 大部分可能造成错误的函数：错误时返回一个错误接口（error），在成功时返回 nil。
  • 重大错误已影响程序的函数：使用 defer、panic、recover 来处理异常，根情况决定宕机还是恢复。

开发建议：

  1. Go语言希望开发者将错误处理视为正常开发必须实现的环节，正确地处理每一个可能发生错误的函数。应合理谨慎使用 panic，大部分情况采用 error 错误返回机制。

  2. Go语言使用返回值返回 error 错误的机制，也能大幅降低编译器、运行时处理错误的复杂度，让开发者真正地掌握错误的处理。

  3. Go语言没有类似 Java 或 .NET 中的异常处理机制，虽然可以使用 defer、panic、recover 模拟，但官方并不主张这样做，Go语言的设计者认为其他语言的异常机制已被过度使用，上层逻辑需要为函数发生的异常付出太多的资源，同时，如果函数使用者觉得错误处理很麻烦而忽略错误，那么程序将在不可预知的时刻崩溃。

参考感谢
错误机制 · 语雀 (yuque.com)
Go基础—— 异常&错误 · 语雀 (yuque.com)
异常 · 语雀 (yuque.com)