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

背竽 · 2025-7-16 22:18:52

本文首发于公众号：Hunter后端
原文链接：Golang基础笔记十二之defer、panic、error

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

defer
panic
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 信息并输出到日志或采用其他能通知到程序运行者的方式。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

账号		自动登录	找回密码
密码			立即注册

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

浏览过的版块

签约作者