概述

        在上一节的内容中，我们介绍了Go的接口，包括：定义接口、实现接口、使用接口、空接口等。在本节中，我们将介绍Go的错误处理。在Go语言中，错误处理是一种重要的编程模式，它用于处理可能出现的错误或异常情况。Go语言采用了一种简洁而直接的错误处理方式，通过使用内置的error类型和约定的返回值，开发人员可以有效地处理和传递错误信息。

errors包

        Go语言中的errors包主要用于进行错误处理，它提供了一些简单的接口和函数，用于创建和操作错误值。下面，我们介绍errors包中一些常见函数的使用方法。

        创建错误：可以使用errors.New()函数来创建一个简单的错误值。它接受一个字符串参数，用于表示错误信息。比如：

          err := errors.New("something is wrong")

        包装错误：可以使用errors.Wrap()函数来包装一个错误值。它接受一个错误值和一个字符串参数，返回一个新的错误值，其中包含了原始错误的详细信息。比如：

          err := errors.Wrap(originalError, "something is wrong")

        获取错误信息：可以使用errors.Unwrap()函数来获取包装错误中的原始错误。它接受一个错误值，返回原始错误。比如：

          originalErr := errors.Unwrap(err)

        判断错误类型：可以使用errors.Is()函数来判断一个错误是否属于特定的类型。它接受一个错误值和一个类型参数，返回一个布尔值表示是否匹配。比如：

          if errors.Is(err, io.EOF)

        错误格式化：可以使用errors.Errorf()函数来创建一个格式化的错误值。它接受一个格式化字符串和变量参数，类似于fmt.Sprintf()函数。比如：

          err := errors.Errorf("something is wrong: %s", errorMessage)

返回错误

        在Go语言中，通常将函数的最后一个返回值定义为error类型，用于指示函数执行过程中是否发生了错误。如果函数执行成功，该错误值为nil；如果函数执行失败，则将相应的错误值赋给错误变量。这种约定使得函数的调用者可以轻松地检查函数是否返回了错误，并根据需要采取相应的处理措施。

        在下面的示例代码中，divide函数接受两个float64类型的参数，并返回一个float64类型的结果和一个error类型的错误。当除数为零时，函数会返回一个非零的错误值，用于描述错误信息。在main函数中，我们通过检查错误变量err是否为nil来判断函数是否执行成功。如果err不为nil，则表示函数执行失败，并打印相应的错误信息；否则，打印函数执行的结果。

package main
import "fmt"
import "errors"
  
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("divisor cannot be zero")
    }
    return a / b, nil
}
func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        // 输出：Result: 5
        fmt.Println("Result:", result)
    }
    result, err = divide(10, 0)
    if err != nil {
        // 输出：Error: divisor cannot be zero
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

        除了直接返回错误值外，还可以使用多返回值的方式在函数内部进行错误处理。在下面的示例代码中，我们使用一个额外的变量来指示函数是否执行成功。

package main  
  
import "fmt"
import "errors"
  
func divide(a, b float64) (float64, bool, error) {
    if b == 0 {
        return 0, false, errors.New("divisor cannot be zero")
    }
    if b == 1 {
        return 0, false, nil
    }
    return a / b, true, nil
}  
  
func main() {
    result, success, err := divide(10, 1)
    if err != nil {
        fmt.Println("Error:", err)
    } else if !success {
        // 输出：divisor cannot be 1
        fmt.Println("divisor cannot be 1")
    } else {
        fmt.Println("Result:", result)
    }
}

抛出异常

        在Go语言中，抛出异常可以使用panic函数。panic函数是一个内置函数，用于表示发生了一个无法恢复的错误。当panic函数被调用时，当前函数的执行会立即停止，并且向上递归调用栈，直到找到适当的defer语句或函数返回。

        panic函数通常用于处理无法处理的错误情况，比如：内存溢出、空指针引用等。当panic函数被调用时，它会传递一个字符串作为参数，表示发生错误的原因，这个字符串可以被捕获并用于错误处理或日志记录。

        在下面的示例代码中，我们用panic函数抛出了异常。在执行panic函数之前，会打印输出字符串“before panic”。在执行panic函数之后，main函数的执行会立即停止，故不会继续执行后面的打印语句。

package main
import "fmt"
func main() {
    // 输出：before panic
    fmt.Println("before panic")
    // 抛出异常
    panic("an exception occured")
    // 以下语句不会被执行
    fmt.Println("after panic")
}

捕获异常

        在Go语言中，捕获异常可以使用recover函数和defer关键字。

        recover函数是一个内建函数，用于从一个panic异常中恢复并继续执行程序。当程序遇到panic时，它会中断当前的执行流程并开始向上层调用栈传播panic，直到被捕获或程序终止。recover函数允许在defer关键字修饰的函数中捕获并处理panic异常，以便程序可以继续执行而不会终止。

        defer关键字用于延迟执行一个函数调用，直到包含它的函数返回之前执行。被defer修饰的函数调用会被推入一个栈中，等到包含它的函数返回时，该函数调用才会被从栈中弹出并执行。defer关键字通常用于在函数返回之前执行一些清理操作，比如：关闭文件、释放资源、打印日志等。它可以用于确保在函数执行结束时，相关的资源被正确释放，避免资源泄漏问题。

        注意：recover函数只能在defer函数中使用，不能在其他上下文中使用。当在defer函数中调用recover时，它会停止panic传播并返回panic的值（如果有的话）。如果没有panic发生，recover函数会返回nil。

        在下面的示例代码中，我们使用defer关键字和匿名函数来创建一个defer函数。在defer函数中，我们调用recover函数来捕获panic异常。如果有panic发生，我们会打印出相应的错误信息。

package main
import "fmt"
func main() {
    defer func() {
        if r := recover(); r != nil {
            // 捕获到异常，输出：an exception caught: an exception occured
            fmt.Println("an exception caught:", r)
        }
    }()
    // 输出：before panic
    fmt.Println("before panic")
    // 抛出异常
    panic("an exception occured")
    // 以下语句不会被执行
    fmt.Println("after panic")
}