Golang基础笔记十二之defer、panic、error

本文首发于公众号：Hunter后端

原文链接：Golang基础笔记十二之defer、panic、error

本篇笔记介绍一下 Golang 里 defer、panic 和 error 的相关概念和操作，以下是本篇笔记目录：

1. defer
2. panic
3. error

1、defer

defer 语句用于延迟执行一个函数，这个函数会在函数返回前执行，无论是正常返回还是触发 panic 之后。

它常用于确保一些文件、链接等资源无论是正常还是异常的情况下被释放。

如果有多个 deder 会按照后进先出的顺序来执行。

1. 后进先出

我们可以先看一个示例：

func main() {     defer fmt.Println("最后输出")     defer fmt.Println("倒数第二个输出")      defer fmt.Println("第二个输出")     defer fmt.Println("第一个输出") } 

这个函数执行后，输出的结果如下：

第一个输出 第二个输出 倒数第二个输出 最后输出 

从这个操作可以看到，它是满足后进先出的顺序的。

2. 函数返回前执行

接下来我们验证一下它会在函数返回前执行：

func main() {     defer fmt.Println("defer 输出")      fmt.Println("正常输出")     fmt.Println("函数的末尾输出") } 

其输出内容如下：

正常输出 函数的末尾输出 defer 输出 

可以看到，defer 执行的功能会在函数末尾的操作之后。

3. 异常操作的 defer

接下来我们模拟一下函数中执行异常的情况：

func main() {     defer fmt.Println("defer 输出")     a := 1     b := 0     fmt.Println(a / b) } 

其输出结果如下：

defer 输出 panic: runtime error: integer divide by zero 

可以看到，虽然在函数中间执行报错了，但是 defer 后的内容仍然被执行了。

因此，defer 操作可以保证一些资源的释放，即便函数在运行中报错。

4. defer 注意事项

1) defer 函数的参数传递

如果 defer 的函数的使用了参数，那么这个参数在当时就被固定了，即便是后面对其进行了修改，也不会改变，比如下面的例子：

func main() {     i := 1     defer fmt.Println("defer i: ", i)      i += 1     fmt.Println("final i: ", i) } 

其输出内容如下：

final i:  2 defer i:  1 

可以看到，即便 i 的值被修改，因为 defer 先被执行，所以 i 的值已经被复制，后面对 i 进行修改后，也不会对 defer 操作的内容有所修改。

而如果变量是引用类型，在操作上是一样的，传递的都是变量的副本，但是因为引用类型传递的是引用的副本，而其共享底层数据是一样的，所以修改后会反映到结果上，其示例如下：

func main() {     s := []int{1, 2, 3}     defer fmt.Println("defer s: ", s)      s[1] = 100     fmt.Println("final s: ", s) } 

其输出结果为：

final s:  [1 100 3] defer s:  [1 100 3] 

2) defer 获取变量最新值

如果我们想要在 defer 逻辑中获取到变量的最新值，我们可以将参数封装到匿名函数内部，延迟到实际执行的时候再求值：

func main() {     i := 1     defer func() { fmt.Println("defer i: ", i) }()      i += 1     fmt.Println("final i: ", i) } 

其输出的内容为：

final i:  2 defer i:  2 

2、panic

panic 是 Golang 里的一种异常机制，用于处理不可恢复的错误，比如数组越界，空指针引用等。

当发生 panic 时，程序会立即停止当前函数的执行，逐层向上执行 defer 并输出错误信息，下面是一个示例：

func main() {     defer fmt.Println("defer content")      fmt.Println("first message")      var a []int     fmt.Println(a[0])      fmt.Println("wont show") } 

输出内容如下：

first message defer content panic: runtime error: index out of range [0] with length 0  goroutine 1 [running]: main.main()         /../main.go:32 +0x8f exit status 2 

1. 主动触发和运行时触发

在程序运行过程中，如果发生了我们没有预料到的错误，就会触发 panic，或者当我们在处理中无法继续处理下去，我们也可以选择主动触发 panic。

运行时触发 panic 就比如上面我们介绍的例子，下面介绍一个主动触发 panic 的示例：

func GetRandomState() bool {     num := rand.Intn(5)     if num < 3 {         return true     } else {         return false     } }  func main() {     if GetRandomState() {         panic("random state error")     } } 

这个函数多执行几次，当返回值为 true 时，就会主动触发 panic，并中断程序：

panic: random state error  goroutine 1 [running]: main.main()         /../main.go:33 +0x38 exit status 2 

2. recover 捕获 panic

我们可以使用 recover 用于在 defer 中捕获 panic，使程序恢复正常执行。

注意，这里的恢复正常执行，并不是跳过发生报错的地方接着执行，而是指在调用这个函数之外的地方接着往后执行，从而使整个 Golang 程序不会崩溃。

下面是一个示例：

func Test() {     defer func() {         if r := recover(); r != nil {             fmt.Println("recovered err info: ", r)         }     }()      if GetRandomState() {         panic("random state error")     } }  func main() {     Test()     fmt.Println("after Test") } 

当程序报错后，recover 可以捕获到 panic 信息，在这里我们将其打印了出来，并且可以看到，调用 Test() 之后的 fmt.Println() 信息被正常打印出来。

如果是在生产环境，我们可以将其写入日志，或者发送邮件等方式通知到对应的负责人，下面是将错误信息打印出来的结果：

recovered err info:  random state error 

根据这个信息，只有简单一个 panic 输出的信息，如果我们想获取更详细的信息，比如，在哪个函数的多少行出了什么报错，我们可以使用下面的操作：

func main() {      defer func() {         if r := recover(); r != nil {             stackBuffer := make([]byte, 1024)             stackSize := runtime.Stack(stackBuffer, false)              fmt.Printf("recovered err info: %s n", stackBuffer[:stackSize])         }     }()      if GetRandomState() {         panic("random state error")     } } 

其中输出的具体的报错信息如下：

recovered err info: goroutine 1 [running]: main.main.func1()         /../main.go:36 +0x51 panic({0x5a6cf20?, 0x5a855f8?})         /usr/local/go/src/runtime/panic.go:791 +0x132 main.main()         /../main.go:43 +0x5f 

可以看到报错信息可以详细到在 main 函数的第 43 行，根据这个信息我们可以再去溯源错误。

3、error

error 是 Golang 的标准错误接口，用于表示错误信息：

type error interface {     Error() string } 

1. 返回 error 信息

我们一般约定函数返回值的最后一个为 error 类型，我们可以使用 errors.New() 的方式来创建一个 error 数据，下面是一个使用示例：

package main  import (     "errors"     "fmt" )  func DivideFunc(a, b int) (int, error) {     if b == 0 {         return 0, errors.New("division by zero")     }     return a / b, nil }  func main() {     result, err := DivideFunc(10, 0)      if err != nil {         fmt.Println("process error:", err)         return     }     fmt.Println("division result: ", result) } 

在这里，我们获取函数返回值，第一个为结果，第二个为 error 信息，处理 error 信息的时候，判断 err 是否为 nil，不为 nil 则说明函数在运行中发生了报错，需要处理。

除了 errors.New() 这种形式，我们也可以使用 fmt.Errorf("division by zero") 的方式返回一个 error 数据：

func DivideFunc(a, b int) (int, error) {     if b == 0 {         return 0, fmt.Errorf("division by zero")     }     return a / b, nil } 

2. 自定义 error

我们可以自定一个 error 信息，用于输出我们自己想要输出的信息，比如我们定义一个 error 信息如下：

type DivideError struct {     Code int     Msg  string }  func (e *DivideError) Error() string {     return fmt.Sprintf("error_code:%d, error_msg:%s", e.Code, e.Msg) } 

在这里，我们使用定义的 DivideError 实现了 error 接口的 Error() 方法，所以可以直接作为 error 类型返回，下面是使用的示例：

func DivideFunc(a, b int) (int, error) {     if b == 0 {         err := &DivideError{Code: -1, Msg: "division by zero"}         return 0, err     }     return a / b, nil } 

3. 检查特定 error 类型

用于判断和检查特定的 error 类型的函数有两个，一个是 errors.Is()，一个是 errors.As()。

errors.Is() 用于判断返回的错误信息是否是某个特定错误实例，而 errors.As() 用于判断错误信息是否是某个特定类型，即进行类型断言。

以下是两个函数的使用示例：

1) errors.Is()

type DivideError struct { 	Code int 	Msg  string }  func (e *DivideError) Error() string {     return fmt.Sprintf("error_code:%d, error_msg:%s", e.Code, e.Msg) }  var divideError = &DivideError{Code: -1, Msg: "division by zero"}  func DivideFunc(a, b int) (int, error) {     if b == 0 {         return 0, divideError     }     return a / b, nil }  func main() {     result, err := DivideFunc(10, 0)      if err != nil {         if errors.Is(err, divideError) {             fmt.Println("divideError: ", err)         } else {             fmt.Println("other error info: ", err)         }     }     fmt.Println("division result: ", result) }  

在这里，先对 DivideError 进行了一个实例化 divideError，在返回错误信息后，使用 errors.Is() 判断是否是该错误。

2) errors.As()

errors.As() 操作如下：

type DivideError struct { 	Code int 	Msg  string }  func (e *DivideError) Error() string {     return fmt.Sprintf("error_code:%d, error_msg:%s", e.Code, e.Msg) }  var divideError = &DivideError{Code: -1, Msg: "division by zero"}  func DivideFunc(a, b int) (int, error) {     if b == 0 {         return 0, divideError     }     return a / b, nil }  func main() {     result, err := DivideFunc(10, 0)      if err != nil {         var divErr *DivideError         if errors.As(err, &divErr) {             fmt.Println("divideError: ", err, divErr.Code, divErr.Msg)         } else {             fmt.Println("other error info: ", err)         }     }     fmt.Println("division result: ", result) } 

在这里，我们定义了一个 divErr 变量，并使用 errors.As() 函数对其进行类型断言，因此，在后面我们我们可以直接通过 divErr 获取到对应的 Code 和 Msg 信息。

以上就是本篇笔记关于 defer、panic 和 error 的相关内容介绍，在实际程序中，我们一般使用 error 来返回一些可预料，可恢复的错误，并在函数调用结束之后捕获到该错误，并决定接下来的程序应该如何操作。

而 panic 则包括主动触发和运行时的被动触发，主动触发为当我们程序运行中遇上一些可能无法继续运行的错误，我们可以选择 panic 并结束程序运行，而运行时的被动触发则是我们无法预料到的一些错误，从而被动中止程序运行。

在触发 panic 后，程序会中止运行，如果我们有一些需要关闭资源的操作，我们可以在开启资源调用的时候就使用 defer 操作来预防程序中止后无法关闭资源的问题，同时我们可以在 defer 中使用 recover 操作来捕获到 panic 信息并输出到日志或采用其他能通知到程序运行者的方式。