2. 基础错误模式：函数返回 error、if err != nil 模式、多返回值中的错误处理

Go 语言没有传统面向对象语言中的异常（Exception）机制，而是采用了一种显式、基于值的错误处理哲学。这种哲学的核心是：错误是普通的值，函数通过返回值将错误传递给调用者，调用者必须显式检查并处理。本章将深入剖析 Go 中最基础、最核心的三种错误处理模式。

2.1 函数返回 error：错误作为一等公民

在 Go 中，error 是一个预定义的接口类型，定义如下：

type error interface {
    Error() string
}

任何实现了 Error() string 方法的类型都可以作为错误值。函数通过在其返回值列表的最后一个位置返回 error 类型，来向调用者报告失败信息。这是 Go 语言中最普遍的错误传递方式。

以下是一个典型的函数返回 error 的示例：

package main

import (
    "errors"
    "fmt"
)

// Divide 执行除法运算，如果除数为0则返回错误。
func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("除数不能为0")
    }
    return a / b, nil
}

func main() {
    result, err := Divide(10, 0)
    if err != nil {
        fmt.Println("发生错误:", err)
        return
    }
    fmt.Println("结果:", result)
}

在这个例子中，Divide 函数通过返回 error 接口，将“除数不能为0”这一业务规则错误显式地传递给了调用者。

2.2 if err != nil 模式：显式错误检查

与某些语言使用 try-catch 块隐式捕获异常不同，Go 要求调用者在每次函数调用后，使用 if err != nil 语句显式地检查错误。这种模式虽然看起来有些冗长，但它带来了几个关键优势：

• 控制流清晰： 错误处理路径与正常业务逻辑路径在代码层面完全分离，阅读代码时可以一目了然地看到所有可能的失败点。
• 避免遗漏： 编译器不会强制检查错误，但 if err != nil 模式在代码审查和静态分析中非常容易被识别，减少了错误被忽略的可能性。
• 资源管理精确： 在检查到错误后，可以立即执行资源清理（如关闭文件、释放锁），而不是等待异常处理机制来展开堆栈。

下面是一个展示 if err != nil 模式在文件读取场景中应用的示例：

func ReadConfig(path string) ([]byte, error) {
    f, err := os.Open(path)
    if err != nil {
        // 错误处理：文件打开失败
        return nil, fmt.Errorf("打开配置文件失败: %w", err)
    }
    defer f.Close() // 确保文件关闭

    data, err := io.ReadAll(f)
    if err != nil {
        // 错误处理：文件读取失败
        return nil, fmt.Errorf("读取配置文件失败: %w", err)
    }

    return data, nil
}

注意，每个可能失败的步骤（os.Open、io.ReadAll）之后都紧跟着一个 if err != nil 检查。这种模式确保了错误不会被无声地传递到后续逻辑中。

2.3 多返回值中的错误处理：组合与解构

Go 函数支持多返回值，这使得将错误与正常结果一起返回变得非常自然。调用者通过多重赋值来解构返回值，并分别处理结果和错误。

多返回值错误处理模式通常遵循以下约定：

以下是一个更复杂的示例，展示了如何在多返回值中处理多个错误来源：

// ParseUserData 解析用户数据，可能返回解析错误和验证错误。
func ParseUserData(raw []byte) (User, error) {
    var user User
    if err := json.Unmarshal(raw, &user); err != nil {
        return User{}, fmt.Errorf("JSON解析失败: %w", err)
    }

    if err := validateUser(user); err != nil {
        return User{}, fmt.Errorf("用户数据验证失败: %w", err)
    }

    return user, nil
}

func validateUser(u User) error {
    if u.Name == "" {
        return errors.New("用户名不能为空")
    }
    if u.Age < 0 || u.Age > 150 {
        return errors.New("年龄超出有效范围")
    }
    return nil
}

在这个例子中，ParseUserData 函数内部调用了两个可能失败的子函数。每个子函数都遵循“多返回值 + if err != nil”模式，将错误逐层向上传递，最终由最外层的调用者统一处理。

2.4 三种基础模式的协同工作

这三种模式并非孤立存在，而是共同构成了 Go 错误处理的基石。下面的 SVG 图展示了它们之间的协作关系：

2.5 常见陷阱与最佳实践

在使用这三种基础模式时，开发者常会遇到以下陷阱：

• 错误被忽略： 使用 _ 忽略错误返回值，如 result, _ := DoSomething()。除非你明确知道该错误无关紧要，否则永远不要忽略错误。
• 错误变量遮蔽： 在 if 块内部使用短变量声明 := 时，可能会意外创建新的局部变量，遮蔽外层的错误变量。
• 错误信息不丰富： 直接返回原始错误而不添加上下文信息，导致调用者无法定位问题根源。应使用 fmt.Errorf("操作失败: %w", err) 包装错误。
• 在循环中累积错误： 在循环中调用可能失败的函数时，错误处理不当可能导致循环提前终止或错误被覆盖。