第 13 课·类型系统入门

错误处理

errorpanicrecoverdefer

Go 并发编程 - 第13课：错误处理

学习目标

完成本课学习后，你将能够：

  1. 理解并正确使用Go语言中 error 接口来处理程序中的常规错误。
  2. 区分“错误”与“恐慌（Panic）”，并掌握它们的正确使用场景。
  3. 使用 defer 和 recover 语句来优雅地处理运行时恐慌。
  4. 编写健壮的、能妥善处理异常情况的Go代码。

核心概念

在Go语言中，错误处理是一个显式的过程。Go不使用像其他语言中常见的 try-catch 机制，而是通过返回值来报告错误。

1. 错误（Error） error 是一个内置的接口类型，其定义非常简单：

type error interface {
    Error() string
}

任何实现了 Error() string 方法的类型都可以被视为一个错误。最常用的创建错误的方式是 errors.New() 和 fmt.Errorf()。

2. 恐慌（Panic） panic 是一种运行时错误，表示程序遇到了无法恢复的、严重的错误。当 panic 被触发时，当前函数会立即停止执行，并开始逐层向外展开（unwinding）其调用栈，执行所有被 defer 的函数。这个过程会一直持续到 main 函数，最终导致程序崩溃并打印错误信息。 关键点： panic 不应该用于常规的错误处理，例如文件未找到或网络连接超时。它主要用于程序逻辑上的不可恢复错误，例如数组越界、空指针解引用或程序初始化失败。

3. 恢复（Recover） recover 是一个内置函数，它可以捕获当前正在发生的 panic，从而阻止程序崩溃。recover 只在 defer 函数内部调用时才有效。 其工作原理是：当 panic 导致栈展开时，它会查找调用栈中最近的 defer 函数。如果在这个 defer 函数中调用了 recover()，panic 就会被捕获，recover() 会返回 panic 时传入的错误值，程序将从导致 panic 的函数调用点之后继续正常执行。

4. 延迟执行（Defer） defer 语句会将其后面的函数调用推迟到外层函数返回之后才执行。无论外层函数是正常返回还是发生 panic 而返回，被 defer 的函数都会执行。这使得 defer 成为清理资源（如关闭文件、释放锁）的完美工具，也是 recover 能够发挥作用的必要条件。

代码示例

示例1：错误接口的基本使用

package main

import (
    "errors"
    "fmt"
    "math"
)

// 自定义一个可能返回错误的函数
func Sqrt(f float64) (float64, error) {
    if f < 0 {
        // 返回一个有意义的错误值
        return 0, errors.New("math: square root of negative number")
    }
    return math.Sqrt(f), nil // 成功时，错误值为 nil
}

func main() {
    // 测试正常情况
    result, err := Sqrt(25)
    if err != nil {
        fmt.Println("Error:", err) // 处理错误
        return
    }
    fmt.Println("Sqrt(25) =", result) // 输出: Sqrt(25) = 5

    // 测试错误情况
    result, err = Sqrt(-4)
    if err != nil {
        fmt.Println("Error:", err) // 输出: Error: math: square root of negative number
        // 这里可以根据不同的错误类型进行不同的处理
        return
    }
    fmt.Println("Sqrt(-4) =", result) // 这行不会执行
}

示例2：Panic 与 Recover

package main

import (
    "fmt"
)

// 可能导致panic的函数
func riskyOperation() {
    fmt.Println("Performing a risky operation...")
    // 模拟一个无法处理的错误，触发panic
    panic("something went terribly wrong!")
}

func main() {
    // 使用defer和recover来安全地调用riskyOperation
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
            // 这里可以记录日志、执行清理等
        }
    }()

    fmt.Println("Starting the program.")
    riskyOperation()
    // 由于panic，以下代码不会执行
    fmt.Println("This line will not be printed.")
}

输出：

Starting the program.
Performing a risky operation...
Recovered from panic: something went terribly wrong!

程序没有崩溃，并优雅地从 panic 中恢复了。

示例3：使用 fmt.Errorf 包装错误上下文

package main

import (
    "fmt"
    "os"
)

func ReadFile(filename string) ([]byte, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        // 使用 %w 包装原始错误，增加上下文
        return nil, fmt.Errorf("failed to read file %s: %w", filename, err)
    }
    return data, nil
}

func main() {
    _, err := ReadFile("nonexistent.txt")
    if err != nil {
        fmt.Println("Error:", err)
        // 输出类似: Error: failed to read file nonexistent.txt: open nonexistent.txt: no such file or directory
    }
}

实践练习

练习1：基础错误处理

编写一个函数 Divide(a, b float64) (float64, error)。当除数 b 为 0 时，返回一个错误。在 main 函数中调用它并处理可能的错误。 要求：

  1. 使用 errors.New 创建错误信息。
  2. 在 main 中使用 if err != nil 模式检查并打印错误。 预期输出（当 b=0 时）：
Error: division by zero

练习2：Panic 与 Recover 实践

编写一个函数 InitializeDatabase()，模拟数据库连接失败并 panic。在 main 函数中，使用 defer 和 recover 捕获这个 panic，并打印一条友好的错误信息：“Database initialization failed. Please check the connection.” 要求：

  1. 在 InitializeDatabase 中调用 panic。
  2. 在 main 中确保 recover 能正确捕获并处理。

练习3：综合挑战（稍难）

编写一个程序，使用 goroutine 执行一个可能会 panic 的任务。

  1. 创建一个函数 ProcessData(id int)，如果 id 为负数则 panic。
  2. 在主 goroutine 中启动多个 ProcessData 的并发调用（其中一些 id 为负）。
  3. 使用 defer 和 recover 确保单个 goroutine 的 panic 不会导致整个程序崩溃，而是被记录下来。 提示： 每个需要安全执行的 goroutine 都应该有自己的 defer/recover 逻辑。 预期： 程序不应崩溃，并为每个 panic 的任务打印类似 "Recovered in goroutine: ...". 的日志。

常见错误

  1. 忽略错误返回值：Go 编译器通常不允许忽略有返回值的函数（除非用 _），但初学者容易忽略 error 返回值，直接使用主返回值，这会导致程序在错误发生时继续运行，产生未定义行为。

    // 错误示例
data, _ := os.ReadFile("config.txt") // 错误被忽略！如果文件不存在，data为nil，后续使用会panic。
process(data)

  2. 滥用 Panic：将 panic 用于可能发生的、可预见的错误（如用户输入错误、文件不存在）。这会让调用者无法优雅地处理错误，破坏程序的健壮性。

    // 错误示例：函数本应返回error
func GetUser(id int) User {
    if id <= 0 {
        panic("invalid user id") // 不好！应该返回 (User, error)
    }
    // ...
}

  3. Recover 使用不当：

    • 在 defer 函数外部调用 recover()，它总是返回 nil，无法捕获任何 panic。
    • 捕获 panic 后不进行任何记录或处理，简单地吞掉错误，这会隐藏严重问题，让调试变得困难。

  4. 在 Goroutine 中遗漏错误处理：在一个新的 goroutine 中启动的函数如果 panic，且没有被 recover，那么整个程序都会崩溃。需要为每个独立的 goroutine 考虑错误处理或恐慌恢复。

小结

  • 错误是预期的：使用 error 接口和多返回值来处理程序中可能发生的、可预见的错误。这是Go处理异常的正常流程。
  • Panic 是意外的：panic 用于表示程序逻辑或状态出现了严重且不可恢复的问题，不应该用于常规的控制流。
  • Recover 是安全网：通过 defer + recover 组合，可以捕获 panic，防止程序崩溃，并执行清理或记录日志。这是在编写鲁棒的、特别是并发环境下的代码时非常重要的工具。
  • 上下文很重要：使用 fmt.Errorf 和 %w 来包装底层错误，为错误添加有用的上下文信息，这极大地有助于调试。

记住，良好的错误处理是编写可靠Go程序的关键。区分好“错误”和“恐慌”的边界，并利用 defer/recover 来保护你的程序，你就能构建出既强大又稳定的系统。下一课，我们将学习如何创建自定义错误类型以及更强大的错误包装技术。

练习编辑器

go
Loading...

继续学习

完成本课后，建议继续学习下一课「自定义错误与错误包装」 以巩固所学知识。