Go语言中的defer，panic，recover 与错误处理
目录
前言
在其他编程语言中，如Java，宕机往往以异常的形式存在。底层抛出异常，上层逻辑通过try...catch...fanally机制捕获异常并处理，没有被捕获到的严重异常会导致程序崩溃，捕获的异常可以被处理，让代码可以继续执行。
Go语言没有异常系统，其使用panic触发宕机类似于其他语言的抛出异常，而recover的宕机恢复机制就对应try...catch机制。recover()函数用来捕获或者说是拦截panic的，阻止panic继续向上层传递。无论是主动调用panic()函数触发的宕机还是程序在运行过程中由Runtime层抛出的异常，都可以配合defer 和 recover 实现异常捕获和恢复，让代码在发生panic后能够继续执行。
Go语言通过
defer、panic和recover三个关键字构建了一种独特的异常处理机制。它们协同工作，使得Go程序能够优雅地处理运行时错误和异常情况。本文将深入浅出地解析这三个关键字的用法、特点以及常见问题与易错点，并通过代码示例进行演示。
三个关键字
defer：在函数中，经常要打开资源（如：文件打开，数据库连接等），为了在函数执行后，及时释放资源，go的设计者提供defer（延时机制）
panic：内置函数，接收一个interface{}类型的值（也就是任何值）作为参数，可接收error类型的变量，输出错误信息，并退出程序。
errors.New("错误说明")：返回一个error类型的值，表示一个错误
recover：内置函数，可以捕获到go中的异常
defer语句
延迟执行
defer语句用于延迟执行一个函数调用，直到包含该defer语句的函数返回时才执行。这在资源释放、日志记录等场景中尤为有用：
package main
import "fmt"
func main() {
defer fmt.Println("Closing file...")
// 执行文件操作...
}
// 输出：Closing file...后进先出（LIFO）
如果有多个defer语句，它们按后进先出（LIFO）顺序执行：
package main
import "fmt"
func main() {
defer fmt.Println("Second deferred call")
defer fmt.Println("First deferred call")
// 执行其他操作...
}
// 输出：
// First deferred call
// Second deferred call在return语句之后执行
defer语句的执行时机在函数返回之前，即使它位于return语句之后：
package main
import "fmt"
func calculate() (result int, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Recovered from panic: %v", r)
}
}()
// 可能触发panic的计算逻辑...
return result, err
}易错点：滥用defer导致性能下降。尽管defer提供了便利，但过多或不必要的使用可能增加函数调用栈的开销。在需要确保资源释放或执行清理操作时合理使用defer。
panic语句
触发运行时错误
panic语句用于触发一个运行时错误，立即停止当前函数的执行，并开始回溯调用栈，直到遇到recover或程序终止：
package main
import "fmt"
func mayPanic() {
if condition {
panic("An error occurred!")
}
}
func main() {
mayPanic()
fmt.Println("This line will not be reached.")
}传递错误信息
panic可以接受任意类型作为参数，通常传递一个字符串或错误接口实例，以便于错误信息的传递和处理：
package main
import (
"errors"
"fmt"
)
func divide(a, b int) (int, error) {
if b == 0 {
panic(errors.New("Division by zero"))
}
return a / b, nil
}
func main() {
_, err := divide(10, 0)
if err != nil {
fmt.Println(err) // 输出：Division by zero
}
}易错点：随意使用panic处理非严重错误。panic应主要用于处理不可恢复的运行时错误，对于可处理的错误，应通过返回错误值的方式传递给调用者。
recover函数
捕获panic
recover函数只能在defer语句中调用，用于捕获当前goroutine发生的panic，并返回panic传入的值。如果没有panic发生，recover返回nil：
package main
import "fmt"
func mayPanic() {
panic("An error occurred!")
}
func handlePanic() {
defer func() {
if r := recover(); r != nil {
fmt.Println("Recovered from panic:", r)
}
}()
mayPanic()
}
func main() {
handlePanic()
fmt.Println("Program continues after panic recovery.")
}易错点：错误地认为recover可以跨goroutine捕获panic。recover只能捕获同一goroutine内发生的panic，对于其他goroutine引发的panic无能为力。在并发编程中，应结合sync.Once、context.Context等工具实现跨goroutine的错误传播与处理。
【##】关于recover()函数的说明
recover()函数被调用后，会返回一个 interface{} 接口类型的返回值，如果返回值等于nil，说明没有触发panic；反之，说明程序发生了panic，就应该采取相应的措施。
示例1：使用recover捕获panic异常，恢复程序的运行。
func funcA() {
fmt.Println("func A")
}
func funcB() {
defer func(){
//捕获panic，并恢复程序使其继续运行
if err := recover(); err != nil {
fmt.Println("recover in funcB")
}
}()
panic("panic in B") //主动抛出异常
}
func funcC() {
fmt.Println("func C")
}
func funcD() {
fmt.Println("func D")
}
func main() {
defer funcA()
defer funcC()
fmt.Println("this is main")
funcB()
defer funcD()
}运行结果：
this is main
recover in funcB
func D
func C
func A《代码分析》当recover捕获到panic时，不会造成整个进程的崩溃，它会从触发panic的位置退出当前函数，然后继续执行后续代码。
【##】recover()的使用注意事项
- recover 必须搭配defer 语句使用，并且recover()函数必须在延迟函数内被调用执行才能正常工作。
- defer一定要在可能引发panic的语句之前定义。
func funcB() {
/*defer func(){
//捕获异常，并恢复程序使其继续运行
if err := recover(); err != nil {
fmt.Println("recover in funcB")
}
}()*/
defer recover() //捕获会失败
panic("panic in B") //主动抛出异常
}defer、panic、recover组成的错误处理
go语言不支持 try...catch...finally，取而代之的是 defer、panic、revocer组合
例子一
看以下代码：
package main
import (
"fmt"
)
func deferTest2(){
var num1 int8 = 10
var num2 int8 = 0
fmt.Println("函数内部代码")
fmt.Println(num1 / num2) // 在这里程序 panic了，因此在该位置退出，且程序不会执行后面的代码
}
func main(){
deferTest2()
fmt.Println("后面的代码...")
}运行结果如下：
使用 defer ，revocer 进行错误处理后，任然可以执行后面的代码，因此修改代码如下：
package main
import (
"fmt"
)
func deferTest2(){
defer func(){ // 函数发生异常后会执行 defer里的代码，并且不会退出程序
err := recover()
if err != nil {
fmt.Println("发生异常：",err)
}
}()
var num1 int8 = 10
var num2 int8 = 0
fmt.Println("函数内部代码")
fmt.Println(num1 / num2)
}
func main(){
deferTest2()
fmt.Println("后面的代码...")
}执行结果如下：
例子二，自定义错误，使用panic 输出错误程序后，退出程序
package main
import (
"fmt"
"errors"
)
func myError(a string) (err error){
if a == "a" {
return nil
}
return errors.New("这是一个自定义错误")
}
func doMyError(){
err := myError("b")
if err != nil { // 如果有错误，则打印错误，并退出程序
panic(err)
}
fmt.Println("继续向后执行...")
}
func main(){
doMyError()
fmt.Println("后面的代码...")
}执行结果为：
当 myError 传 a的时候，执行结果如下：
我们再上面代码加入defer语句处理错误后：
import (
"fmt"
"errors"
)
func myError(a string) (err error){
if a == "a" {
return nil
}
return errors.New("这是一个自定义错误")
}
func doMyError(){
defer func(){
err := recover()
if err != nil {
fmt.Println("出现的error为：",err)
}
}()
err := myError("b")
if err != nil {
panic(err) // 发生panic 后，执行压入栈的defer语句，且程序不会终止
}
fmt.Println("继续向后执行...") // 发生panic 后不会执行该语句
}
func main(){
doMyError()
fmt.Println("后面的代码...")
}执行结果为：
万码优才-数字技术人才找工作上万码优才！招聘求职找工作！
总结
defer：用于延迟执行函数调用，确保在函数返回前执行。它可以用于资源释放、日志记录等场景。多个 defer 语句按照 后进先出 的顺序执行，传参时需要注意变量的求值时机。
panic：用于处理严重错误，立即终止当前函数的执行，并开始回溯调用栈。panic 会触发当前 goroutine 中的所有 defer，但不会影响其他 goroutine。
recover：用于捕获 panic，只能在 defer 延迟函数中使用。通过 recover，你可以在 panic 发生时捕获它，并采取适当的措施来处理错误，从而避免程序崩溃。
defer、panic 、recover和 语句的组合有如下几个特性：
- recover 必须搭配defer 语句使用，并且recover()函数必须在延迟函数内被调用执行才能正常工作。
- defer一定要在可能引发panic的语句之前定义。
- 有panic，没recover，程序宕机。
- 有panic，也有recover，程序不会宕机。执行完对应的defer后，从宕机点退出所在函数返回到主调函数中，继续执行后续代码。
<提示>
在panic触发的defer语句内，可以继续使用panic，进一步将错误外抛直至程序整体崩溃。
如果想在捕获panic时设置当前函数的返回值，可以对返回值使用命名返回值方式直接进行设置。
Go语言提供了两种错误处理的方式，一种是借助 panic 和 recover 的抛出捕获机制，另一种是使用error接口错误类型。在实际的开发工作中，可以根据实际需求选择合适的错误处理方式。
https://wanmayoucai.com/home?channeltype=drsy&channelid=1310002原文地址：https://blog.csdn.net/lovedingd/article/details/144700554
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！