一、前言

本文主要以下几方面介绍Go语言中错误处理Error:

• 为什么需要异常处理

• 不同开发语言错误处理方式

• Error初体验

• 自定义Error

• 异常终止收尾处理defer

• 异常捕获recover

二、为什么需要异常处理

异常处理在开发语言中起到重要的作用，原因如下：

• 错误检测和处理：异常处理允许开发人员检测和处理程序中的错误情况。当程序执行过程中出现错误或异常情况时，异常处理机制可以捕获这些异常并采取适当的措施，而不会导致程序崩溃或产生不可预测的结果。

• 提高程序健壮性：异常处理有助于增强程序的健壮性。通过处理潜在的错误情况，程序可以更容易地继续执行，而不会受到意外错误的影响。这有助于确保程序在面对异常情况时能够继续运行，而不会完全失败。

• 分离正常流程和异常流程：异常处理允许将正常的程序逻辑与处理异常的逻辑分离开来。这使得代码更易于维护和理解，因为正常情况的处理逻辑与异常情况的处理逻辑可以分开编写。

• 提供错误信息：异常处理可以捕获异常并生成有关错误的详细信息，这有助于开发人员诊断和修复问题。错误信息通常包括异常类型、发生异常的位置和可能导致异常的原因。

• 改进用户体验：在应用程序中实现良好的异常处理可以改善用户体验。当用户面临问题时，他们可能会得到有用的错误消息，而不是仅仅看到程序崩溃或不断闪烁的错误消息。

三、不同开发语言错误处理方式

不同的开发语言在错误处理方面有各自的方式和机制。以下是一些常见的编程语言的错误处理方式：

Java：

• Java 使用异常处理机制，所有可能引发异常的代码都应该包装在try-catch块中。当异常发生时，程序会跳转到相应的catch块进行处理。

• Java 异常分为检查异常（checked exception）和非检查异常（unchecked exception）。检查异常需要显式地在方法签名中声明或捕获，而非检查异常通常是运行时异常，不需要显式声明。

Python：

• Python 使用try-except块来捕获异常。当异常发生时，程序会跳转到匹配的except块进行处理。

• Python还提供了finally块，可以用来执行无论是否发生异常都必须执行的代码。

• Python还有raise语句，允许开发人员手动引发异常。

C++：

• C++ 使用try-catch块来捕获异常，类似于Java。

• C++还支持RAII（资源获取即初始化）机制，通过在对象的构造函数中分配资源并在析构函数中释放资源，可以在异常情况下正确管理资源。

JavaScript：

• JavaScript 使用try-catch块来捕获异常。不同于Java，JavaScript异常处理通常用于处理异步操作中的错误，如Promise。

• JavaScript也可以使用throw语句来手动引发异常。

C#：

• C#与Java类似，使用try-catch块来捕获异常。

• C#还提供了finally块和using语句，用于资源管理和确保资源被释放，即使发生异常也能执行必要的清理操作。

Ruby：

• Ruby 使用begin-rescue-end块来捕获异常。

• Ruby还支持ensure块，用于在异常处理完成后执行清理操作。

不同的编程语言有不同的异常类别和处理机制，但通常它们都支持try-catch（或类似的结构）以及手动引发异常的能力。

四、Error初体验

Go 语言中的错误处理采用了一种独特的方式，它使用了一个专门的错误类型 error 和多返回值来处理错误。

下面进行读取文件内容示例，将下面代码粘贴到00-errorHandling-00.go文件中

package main

import (

    "fmt"

    "io/ioutil"

)

func main() {

    f, err := ioutil.ReadFile("./111.txt")

    if err != nil {

        fmt.Println("读取文件内容失败:", err.Error())

    } else {

        fmt.Println(string(f))

    }

}

针对上面代码分为几个部分进行详细说明：

部分 1 – 导入包

import (
    "fmt"
    "io/ioutil"
)

这里使用 import 语句导入了两个标准库的包，fmt 用于格式化输出，io/ioutil 用于文件操作。

部分 2 – func main()函数

func main() {

    // ...

}

这是程序的入口点，main 函数会在程序启动时自动执行。在这里，你定义了程序的主要逻辑。

部分 3 – 文件读取操作

f, err := ioutil.ReadFile("./111.txt")

这行代码使用 ioutil.ReadFile 函数来读取名为 “111.txt” 的文件的内容，并将结果存储在变量 f 中。同时，它会捕获可能出现的错误，将错误信息存储在变量 err 中。

部分 4 – 错误处理

if err != nil {
    fmt.Println("读取文件内容失败:", err.Error())
} else {
    fmt.Println(string(f))
}

这是一个条件语句，用于检查文件读取操作是否发生了错误。如果 err 不为 nil，表示发生了错误，程序将进入 if 分支并打印错误信息。否则，程序将进入 else 分支并打印读取的文件内容。

在当前目录没有创建111.txt的前提下，执行上面代码,观察到返回读取文件内容失败

$ go run .\00-errorHandling-00.go

读取文件内容失败: open ./111.txt: The system cannot find the file specified.

此时在当前目录创建111.txt，输入内容”正在学习Go”后，再次执行上面代码,观察到返回文件内容

$ go run .\00-errorHandling-00.go

正在学习Go

五、自定义Error

在 Go 语言中，我们可以通过创建实现了 error 接口的自定义类型来自定义错误。error 接口只包含一个方法 Error()，该方法返回一个字符串，用于描述错误的详细信息。

创建自定义错误的一般步骤：

1. 定义一个新的类型，通常是一个结构体，用来表示自定义的错误。

2. 在该类型上实现 error 接口的 Error() 方法，以返回错误的描述信息。

下面进行示例说明，通过Go 语言标准库中的两种方法来处理自定义错误：使用 errors.New() 创建自定义错误和使用 fmt.Errorf() 创建自定义错误。

将下面代码粘贴到01-errorHandling-00.go文件

package main
import (
    "errors"
    "fmt"
)
// 定义一个函数，做除法运算
func division(i1, i2 float64) (res float64, err error) {
    fmt.Println("需要计算的数字是:", i1, i2)
    if i2 == 0 {
        return 0, errors.New("输入的分母不能为0")
    } else {
        res = i1 / i2
        return res, nil
    }
}
func main() {
    // 自定义err，有两种方法：语法糖和使用var定义。这里使用的是语法糖
    err := errors.New("这是一个自定义错误")
    fmt.Println(err)
    err2 := fmt.Errorf("这是一个自定义报错:%s,它是使用fmt生成的", "这是错误内容")
    fmt.Println("这是一个使用fmt定义的错误:", err2.Error())
    res, err3 := division(2, 0)
    if err3 != nil {
        fmt.Println("计算错误:", err3.Error())
    } else {
        fmt.Println("计算结果:", res)
    }
}

针对上面代码分为几个部分进行详细说明：

部分 1 – 导入包和定义函数

import (

    "errors"

    "fmt"

)

// 定义一个函数，做除法运算

func division(i1, i2 float64) (res float64, err error) {

    // ...

}

这部分代码包括导入两个标准库包 errors 和 fmt，以及定义了一个名为 division 的函数，该函数用于执行除法运算并处理可能的错误。

部分 2 – division函数

func division(i1, i2 float64) (res float64, err error) {
    fmt.Println("需要计算的数字是:", i1, i2)
    if i2 == 0 {
        return 0, errors.New("输入的分母不能为0")
    } else {
        res = i1 / i2
        return res, nil
    }
}

这是 division 函数的定义，它接受两个浮点数参数 i1 和 i2，执行除法运算。如果 i2 为零，它会返回一个自定义错误，否则返回计算结果和 nil 表示没有错误。

部分 3 – main函数

func main() {

    // ...

}

这是程序的入口函数，它包含了主要的代码逻辑。

部分 4 – 自定义错误示例

err := errors.New("这是一个自定义错误")

这行代码使用 errors.New() 函数创建一个自定义错误，并将其分配给变量 err。

部分 5 – 格式化自定义错误

err2 := fmt.Errorf("这是一个自定义报错:%s,它是使用 fmt 生成的", "这是错误内容")

这行代码使用 fmt.Errorf() 函数创建一个带有格式化字符串的自定义错误，并将其分配给变量 err2。

部分 6 – 调用 division 函数

res, err3 := division(2, 0)

这行代码调用了 division 函数来进行除法运算，同时捕获可能的错误。计算结果存储在 res 变量中，错误存储在 err3 变量中。

部分 7 – 错误处理和输出

if err3 != nil {
    fmt.Println("计算错误:", err3.Error())
} else {
    fmt.Println("计算结果:", res)
}

这是一个条件语句，用于检查是否有错误发生。如果 err3 不为 nil，表示发生了错误，将打印错误信息。否则，将打印计算结果。

运行上面代码

$ go run .\01-errorHandling-00.go
这是一个自定义错误
这是一个使用fmt定义的错误: 这是一个自定义报错:这是错误内容,它是使用fmt生成的
需要计算的数字是: 2 0
计算错误: 输入的分母不能为0

六、异常终止panic

6.1 基本含义

在 Go 语言中，panic 是一种用于处理严重错误的机制。当程序遇到无法继续执行的情况时，可以使用 panic 来引发异常，中止程序的正常执行流程。这通常用于处理不可恢复的错误情况，如数组越界、除以零等。

6.2 基本语法

panic 的基本语法如下

panic(expression)

• expression 是一个可以求值为任何类型的表达式，通常是一个字符串，用于描述触发 panic 的错误情况。它是 panic 的参数，用于提供关于发生的错误的描述信息。

6.3 使用场景

panic 主要用于处理不可恢复的错误，例如文件无法打开、关键数据丢失等。在正常的错误处理中，通常使用错误值（error）来表示和处理错误，而不是触发 panic。panic 应该被谨慎使用，仅用于真正的紧急情况。

panic 是一种用于处理紧急错误的机制，它可以让你中止程序的正常执行流程，并在必要时进行恢复，但它不应该用于常规错误处理。在编写代码时，建议优先考虑使用错误值（error）来处理错误，而不是触发 panic。

6.4 示例说明

下面定义一个数据库连接函数，输入空地址和空端口后使用panic 终止程序。将下面代码粘贴到02-errorHandling-00.go文件

package main

import (

    "errors"

    "fmt"

    "time"

)

// 定义一个数据库连接函数

func connectdatabase(address string, port int) (string, error) {

    // 如果address和port为空

    if address == "" || port == 0 {

        return "", errors.New("无法连接数据库")

    } else {

        return "数据库连接失败", nil

    }

}

func main() {

    s, err := connectdatabase("", 0)

    for {

        // 使用for循环模拟启动程序

        time.Sleep(5 * time.Second)

        if err != nil {

            fmt.Println(err)

            panic(err) // 退出程序

        } else {

            fmt.Println(s)

        }

    }

}

针对上面代码分为几个部分进行详细说明：

部分 1 – 导入包

import (
    "errors"
    "fmt"
    "time"
)

这部分代码导入了需要的包，包括 errors 用于创建错误，fmt 用于打印输出，以及 time 用于控制循环等待时间。

部分 2 – 定义 connectdatabase 函数

func connectdatabase(address string, port int) (string, error) {
    if address == "" || port == 0 {
        return "", errors.New("无法连接数据库")
    } else {
        return "数据库连接失败", nil
    }
}

这是一个用于模拟数据库连接的函数。它接受一个地址字符串和一个端口号作为参数，如果地址或端口为空，则返回一个自定义的错误；否则，返回一个表示数据库连接失败的字符串。

部分 3 – main 函数

func main() {
    s, err := connectdatabase("", 0)
    for {
        time.Sleep(5 * time.Second)
        if err != nil {
            fmt.Println(err)
            panic(err) // 退出程序
        } else {
            fmt.Println(s)
        }
    }
}

这是主函数。首先，它调用 connectdatabase 函数并将返回的字符串和错误值分别存储在 s 和 err 变量中。然后，使用 for 循环模拟程序的运行，每次迭代等待 5 秒。在每次迭代中，它检查 err 是否为 nil，如果不为 nil，则打印错误信息并通过 panic 退出程序；否则，打印数据库连接失败的消息。

运行上面代码

$ go run .\02-errorHandling-00.go

无法连接数据库

panic: 无法连接数据库

goroutine 1 [running]:

main.main()

        C:/Go进阶-错误处理Error/02-errorHandling-00.go:27 +0x98

exit status 2

6.5 注意事项

使用 panic 是一种在 Go 语言中处理异常情况的机制，但需要非常小心。以下是关于 panic 使用的一些重要注意事项：

• 避免滥用 panic：panic 应该被视为一种紧急情况下的机制，而不是用于正常错误处理的工具。不应该滥用 panic 来掩盖或忽略错误。正常的错误处理应该使用普通的错误返回值。

• 只在严重错误情况下使用 panic：panic 应该用于表示程序无法继续执行的严重错误，如空指针解引用、数组越界等。不应该在预期的、可以通过编程逻辑处理的情况下使用 panic。

• 在恢复之前不要修改数据：如果在发生 panic 后修改数据，可能会导致不确定的行为。通常，在使用 recover 恢复 panic 之前，不应该对程序状态进行任何修改。

• 不要滥用 recover：recover 应该用于处理可预见的异常情况，并确保程序在异常情况下继续运行。不要滥用 recover 来掩盖程序中的逻辑错误或不合理的代码。

• 避免在并发程序中使用 panic：在并发程序中，一个 goroutine 的 panic 不会影响其他 goroutine 的执行。因此，在并发环境中使用 panic 可能会导致不一致的状态。要在并发程序中进行错误处理，请使用错误返回值。

• 使用 panic 和 recover 建立清晰的约定：如果你在代码中使用 panic 和 recover，请确保建立清晰的约定，以便团队中的其他成员能够理解和维护代码。明确规定在哪些情况下使用 panic，以及如何使用 recover 进行处理。

• 记录错误信息：在 panic 发生时，通常应该记录错误信息，以便进行调试和问题排查。这可以通过将错误信息写入日志或向用户返回友好的错误消息来完成。

• 避免在库代码中使用 panic：如果你在开发库或包，应该避免使用 panic。库代码中的 panic 会影响调用方，而且不容易预测。通常，库应该使用错误返回值来报告问题。

七、异常终止收尾处理defer

7.1 基本含义

defer 是 Go 语言中的一个非常有用的关键字，用于在函数执行结束之前执行一些操作。defer 常用于确保某些代码在函数退出之前得到执行，无论函数是正常返回还是发生了错误（panic）。

7.2 基本语法

defer 的基本语法如下：

defer functionCall(arguments)

• functionCall 是一个函数或方法的调用。

• arguments 是函数调用的参数列表（如果有的话）。

defer 语句会将指定的函数调用推迟到包含它的函数（或方法）执行完毕之后，无论是正常返回还是发生 panic。

7.3 使用场景

defer 可以用于各种场景，包括资源清理、文件关闭、锁的释放、记录函数执行时间等。它的几个常见用途如下：

• 对于数据库，关闭连接池

• 对于文件，关闭文件句柄，以避免资源泄漏

• 记录一些异常日志

• 资源回收和数据返回

• 异常时的恢复

7.4 defer顺序

如果在一个函数内包含多个 defer 语句，它们会按照后进先出（LIFO）的顺序执行。最后一个 defer 语句会在函数返回之前被最先执行，倒数第二个会在倒数第二个位置被执行，以此类推。

7.5 示例说明

下面进行演示 defer 语句的执行顺序和错误处理。将下面代码粘贴到03-errorHandling-00.go文件

package main

import (

    "errors"

    "fmt"

)

// 定义一个数据库连接函数

func connectdatabase(address string, port int) (string, error) {

    // 如果address和port为空

    if address == "" || port == 0 {

        return "", errors.New("无法连接数据库")

    } else {

        return "数据库连接失败", nil

    }

}

func returnDataToFrontend(msg string) {

    fmt.Println("返回给前端的数据是：", msg)

}

func main() {

    msg := "返回给前端的数据"

    // 测试defer顺序，后进先出

    defer returnDataToFrontend("1")

    defer returnDataToFrontend("2")

    defer returnDataToFrontend("3")

    defer returnDataToFrontend("4")

    defer returnDataToFrontend(msg)

    _, err := connectdatabase("", 0)

    if err != nil {

        fmt.Println(err)

        panic(err)

    }

}

针对上面代码分为几个部分进行详细说明：

部分 1 – 导入包

import (
    "errors"
    "fmt"
)

这部分代码导入了两个包，"errors" 用于处理错误，"fmt" 用于格式化和打印输出。

部分 2 – 定义 connectdatabase 函数

func connectdatabase(address string, port int) (string, error) {
    if address == "" || port == 0 {
        return "", errors.New("无法连接数据库")
    } else {
        return "数据库连接失败", nil
    }
}

这是一个函数，用于模拟数据库连接。它接受两个参数，address（地址）和 port（端口），并返回一个字符串和一个错误。如果 address 或 port 为空，它返回一个表示无法连接数据库的错误；否则，返回一个表示数据库连接失败的消息。

部分 3 – 定义 returnDataToFrontend 函数

func returnDataToFrontend(msg string) {

    fmt.Println("返回给前端的数据是：", msg)

}

这个函数接受一个字符串参数 msg，并将其打印出来，模拟将数据返回给前端。

部分 4 – main 函数

func main() {
    msg := "返回给前端的数据"
    // 使用多个 defer 语句，推迟函数的执行
    defer returnDataToFrontend("1")
    defer returnDataToFrontend("2")
    defer returnDataToFrontend("3")
    defer returnDataToFrontend("4")
    defer returnDataToFrontend(msg)
    // 调用 connectdatabase 函数，检查是否发生错误
    _, err := connectdatabase("", 0)
    if err != nil {
        fmt.Println(err)
        panic(err)
    }
}

这是 main 函数，是程序的入口点。在这个函数中：

• 定义了一个字符串变量 msg，用于存储将要返回给前端的数据。

• 使用了多个 defer 语句，推迟了多个 returnDataToFrontend 函数的调用。这些函数会在 main 函数执行完毕之前按照后进先出（LIFO）的顺序执行。

• 调用了 connectdatabase 函数，尝试模拟数据库连接，同时检查是否发生了错误。如果发生了错误，会打印错误信息并通过 panic 退出程序。

运行上面代码

$ go run .\03-errorHandling-00.go
无法连接数据库
返回给前端的数据是： 返回给前端的数据
返回给前端的数据是： 4
返回给前端的数据是： 3
返回给前端的数据是： 2
返回给前端的数据是： 1
panic: 无法连接数据库
goroutine 1 [running]:
main.main()
        C:/Go进阶-错误处理Error/03-errorHandling-00.go:34 +0x130
exit status 2

7.6 注意事项

在使用 defer 时，需要注意以下几个重要的事项：

• 延迟函数的执行顺序：延迟函数的执行顺序是后进先出（LIFO）的，也就是最后一个延迟函数被添加的会最先执行，依此类推。这意味着在一段代码中，最后一个 defer 语句将最先执行，而第一个 defer 语句将最后执行。

• 不要滥用 defer：虽然 defer 是一个强大的工具，但不应该滥用。过多的 defer 语句可能会使代码难以理解和维护。只有在确实需要在函数退出时执行某些操作（如资源清理、日志记录等）时才应使用 defer。

• 延迟函数的参数在 defer 语句出现时计算：如果在 defer 语句中传递了函数参数，这些参数将在 defer 语句出现时计算，而不是在实际执行延迟函数时计算。这可能会导致一些意外行为，因此应谨慎使用。

• 不要在循环中滥用 defer：在循环中使用 defer 时需要格外小心，因为它们可能在循环结束后才执行，导致意外的结果。通常，可以将 defer 移动到循环内部的匿名函数中，以确保在每次迭代中都能按预期执行。

• defer 在函数退出时执行：无论函数是正常返回还是由于 panic 导致异常退出，defer 延迟函数都会在函数退出时执行。这使得它们适用于资源清理和日志记录，确保这些操作不会被遗漏。

• 注意内存和性能开销：虽然 defer 是一个有用的功能，但在一些性能关键的场景中可能会引入不必要的开销。因为延迟函数的调用需要保存函数的参数和上下文，所以在高性能的代码中要谨慎使用。

八、异常捕获recover

8.1 基本含义

recover 是 Go 语言中的一个内建函数，用于在发生 panic 时进行错误恢复和处理。recover 的主要含义是捕获 panic，防止程序崩溃，并允许我们在 panic 发生后进行一些必要的清理操作，然后正常退出程序。通常，recover 被放置在一个 defer 语句中，以便在函数退出时捕获 panic。

8.2 基本语法

recover 的基本语法比较简单，它是一个内建函数，没有参数。以下是 recover 的基本语法：

func recover() interface{}

• recover 是一个函数，不需要传递参数。

• 它返回一个 interface{} 类型的值，表示捕获到的 panic 的值。如果没有捕获到 panic，则返回 nil。

8.3 使用场景

recover 主要用于处理 panic，以防止程序崩溃，并在发生异常情况时采取一些必要的措施。以下是 recover 的常见使用场景：

1.错误处理：recover 可以用于捕获 panic 并在发生错误时进行处理。这包括记录错误信息、向日志中写入错误、发送错误报告，或者向用户返回友好的错误消息。

defer func() {
    if r := recover(); r != nil {
        // 处理错误，如记录日志
        log.Println("发生了一个错误:", r)
        // 或者返回友好的错误消息给用户
        http.Error(w, "服务器内部错误", http.StatusInternalServerError)
    }
}()

2.资源清理：在发生 panic 时，程序可能会在资源（如文件、数据库连接、网络连接等）没有被适当关闭的情况下退出。使用 recover 可以确保在程序退出前执行必要的资源清理操作。

defer func() {
    if r := recover(); r != nil {
        // 关闭数据库连接或其他资源
        db.Close()
    }
}()

3.优雅地关闭服务器：在服务器应用中，recover 可以用于捕获 panic 并优雅地关闭服务器，以避免中断正在进行的请求。

func main() {
    defer func() {
        if r := recover(); r != nil {
            // 处理 panic，关闭服务器
            server.Stop()
        }
    }()
    // 启动服务器
    server.Start()
}

4.测试和调试：在测试代码中，recover 可以捕获测试函数中的 panic，从而使测试不会因为一个单元测试用例的失败而中断。

func TestSomething(t *testing.T) {
    defer func() {
        if r := recover(); r != nil {
            t.Errorf("测试发生了 panic: %v", r)
        }
    }()
    // 测试代码
}

8.4 示例说明

下面演示如何使用 defer 和 recover 来处理 panic，以确保程序在异常情况下也能够正常执行，并提供错误信息的记录或处理。将下面代码粘贴到04-errorHandling-00.go文件

package main

import "fmt"

func printSliceData(s []string) {

    defer func() { //匿名函数

        fmt.Println("程序执行失败，捕获异常")

        if err := recover(); err != nil {

            // recover捕获panic的报错；尝试恢复，防止程序退出

            fmt.Println("已经捕获到错误:", err)

            // 记录日志或传给前端提示信息

        }

    }()

    fmt.Println("切片的内容：", s)

    fmt.Println("切片的第三个值是:", s[2])

}

func main() {

    s := []string{"a", "b"}

    printSliceData(s)

}

针对上面代码分为几个部分进行详细说明：

部分 1 – 导入包

import "fmt"

这部分代码导入了 "fmt" 包，用于格式化和打印输出。

部分 2 – printSliceData 函数

func printSliceData(s []string) {
    defer func() { // 匿名函数，用于捕获异常
        fmt.Println("程序执行失败，捕获异常")
        if err := recover(); err != nil {
            // recover 捕获 panic 的报错；尝试恢复，防止程序退出
            fmt.Println("已经捕获到错误:", err)
            // 记录日志或传给前端提示信息
        }
    }()
    fmt.Println("切片的内容：", s)
    fmt.Println("切片的第三个值是:", s[2]) // 引发 panic
}

• printSliceData 函数接受一个字符串切片 s 作为参数。

• 在函数内部，使用 defer 创建了一个匿名函数，该匿名函数将在函数返回之前执行。

• 在匿名函数内部，首先打印了一个提示消息，表示程序执行失败并捕获了异常。

• 接下来使用 recover 检查是否发生了 panic。如果捕获到 panic，则会打印错误信息。

• 最后，函数尝试打印切片的内容和切片的第三个元素（在这里会引发 panic，因为切片 s 中只有两个元素）。

部分 3 – main 函数

func main() {
    s := []string{"a", "b"}
    printSliceData(s)
}

• main 函数创建一个包含两个字符串的切片 s。

• 然后，它调用 printSliceData 函数，将切片 s 作为参数传递给它。

运行上面代码

$ go run .\04-errorHandling-00.go
切片的内容： [a b]
程序执行失败，捕获异常
已经捕获到错误: runtime error: index out of range [2] with length 2

8.5 注意事项

使用 recover 来处理 panic 时需要注意以下几个重要的事项：

• recover 只能在 defer 中使用：recover 只有在延迟函数（defer）中才有效。它用于捕获同一函数内部发生的 panic，并允许在函数退出之前进行处理。在非延迟函数中使用 recover 是无效的。

• recover 必须在可能引发 panic 的代码之后使用：如果 recover 在可能引发 panic 的代码之前使用，它将无法捕获 panic。因此，确保 recover 放置在可能引发 panic 的代码之后。

• recover 必须在相同的 goroutine 中使用：recover 只能捕获同一 goroutine 中的 panic。如果 panic 发生在一个不同的 goroutine 中，recover 将无法捕获它。

• recover 的返回值类型是 interface{}：recover 返回的是 interface{} 类型，因此需要使用类型断言来确定 panic 的值的具体类型。

• 避免滥用 recover：recover 应该用于处理可预见的错误情况，而不是用于掩盖或忽略错误。滥用 recover 可能会导致难以调试的问题，并影响代码的可维护性。

• 记录错误信息：使用 recover 捕获 panic 后，应该记录错误信息，以便进行调试和问题排查。通常，将错误信息写入日志或向用户返回友好的错误消息。

• 恢复后应该清理资源：如果 panic 可能导致资源泄漏（如打开的文件、数据库连接等），则在恢复后应该进行适当的资源清理。

• 不要滥用 panic 和 recover 代替错误处理：panic 和 recover 应该被视为一种紧急情况下的机制，而不是用于正常错误处理的工具。正常的错误处理应该使用普通的错误返回值。