编辑“︁Go 错误处理”︁（章节）

= Go错误处理 =

Go语言采用显式错误处理机制，强调开发者主动处理可能发生的错误情况。这种设计哲学与传统的异常处理机制（如try-catch）有本质区别，是Go控制流中的重要组成部分。

== 基本概念 ==

在Go中，错误（error）是一个内置接口类型：
<syntaxhighlight lang="go">
type error interface {
    Error() string
}
</syntaxhighlight>

错误处理的典型模式是通过多返回值机制，将错误作为函数的最后一个返回值：
<syntaxhighlight lang="go">
result, err := someFunction()
if err != nil {
    // 处理错误
}
// 继续正常流程
</syntaxhighlight>

=== 错误创建 ===

标准库提供了两种主要错误创建方式：

1. 使用<code>errors.New</code>：
<syntaxhighlight lang="go">
err := errors.New("文件未找到")
</syntaxhighlight>

2. 使用<code>fmt.Errorf</code>（支持格式化）：
<syntaxhighlight lang="go">
err := fmt.Errorf("无效的用户ID: %d", userID)
</syntaxhighlight>

== 错误处理模式 ==

=== 基本错误检查 ===
最常用的模式是立即检查错误：
<syntaxhighlight lang="go">
file, err := os.Open("config.json")
if err != nil {
    log.Fatal("无法打开配置文件:", err)
}
defer file.Close()
</syntaxhighlight>

=== 错误类型断言 ===
当需要区分不同类型的错误时：
<syntaxhighlight lang="go">
if err != nil {
    if os.IsNotExist(err) {
        fmt.Println("文件不存在")
    } else if os.IsPermission(err) {
        fmt.Println("权限不足")
    } else {
        fmt.Println("未知错误:", err)
    }
}
</syntaxhighlight>

=== 自定义错误类型 ===
定义结构体实现error接口：
<syntaxhighlight lang="go">
type APIError struct {
    StatusCode int
    Message    string
}

func (e *APIError) Error() string {
    return fmt.Sprintf("API错误[%d]: %s", e.StatusCode, e.Message)
}

// 使用示例
func GetUser(id int) (*User, error) {
    if id < 1 {
        return nil, &APIError{400, "无效的用户ID"}
    }
    // ...
}
</syntaxhighlight>

== 高级错误处理 ==

=== 错误包装 ===
Go 1.13引入了错误包装机制：
<syntaxhighlight lang="go">
if err != nil {
    return fmt.Errorf("处理用户数据失败: %w", err)
}
</syntaxhighlight>

使用<code>errors.Is</code>和<code>errors.As</code>进行检查：
<syntaxhighlight lang="go">
var apiErr *APIError
if errors.As(err, &apiErr) {
    fmt.Println("捕获到API错误:", apiErr.StatusCode)
}
</syntaxhighlight>

=== panic和recover ===
用于处理不可恢复的错误：
<syntaxhighlight lang="go">
func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("恢复panic:", r)
        }
    }()
    panic("发生严重错误")
}
</syntaxhighlight>

== 最佳实践 ==

1. '''始终检查错误'''：不要忽略函数返回的错误
2. '''提供有意义的错误信息'''：帮助调试和问题定位
3. '''避免过度使用panic'''：仅在真正不可恢复的情况下使用
4. '''考虑错误上下文'''：使用错误包装保留原始错误
5. '''文档化可能返回的错误'''：让调用者知道需要处理哪些错误

== 实际案例 ==

=== 文件处理示例 ===
<syntaxhighlight lang="go">
func ReadConfig(path string) ([]byte, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, fmt.Errorf("打开配置文件失败: %w", err)
    }
    defer file.Close()

    data, err := io.ReadAll(file)
    if err != nil {
        return nil, fmt.Errorf("读取配置文件失败: %w", err)
    }

    return data, nil
}
</syntaxhighlight>

=== HTTP服务错误处理 ===
<syntaxhighlight lang="go">
func handleRequest(w http.ResponseWriter, r *http.Request) {
    user, err := getUserFromDB(r.FormValue("id"))
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            http.Error(w, "用户不存在", http.StatusNotFound)
        } else {
            http.Error(w, "服务器错误", http.StatusInternalServerError)
            log.Printf("处理请求失败: %v", err)
        }
        return
    }
    // 处理正常情况...
}
</syntaxhighlight>

== 错误处理流程图 ==
<mermaid>
graph TD
    A[调用函数] --> B{是否有错误?}
    B -->|是| C[处理错误]
    B -->|否| D[继续正常流程]
    C --> E[记录日志/返回错误/恢复]
    E --> F[结束或重试]
    D --> G[执行后续操作]
</mermaid>

== 数学表达 ==

错误处理可以被视为程序控制流的分支决策。设<math>P</math>为程序状态，<math>E</math>为错误条件，则：

<math>
P' = \begin{cases} 
f_{error}(P) & \text{如果 } E(P) \text{ 为真} \\
f_{normal}(P) & \text{否则}
\end{cases}
</math>

其中<math>f_{error}</math>和<math>f_{normal}</math>分别代表错误处理和正常执行的函数。

[[Category:编程语言]]
[[Category:Go]]
[[Category:Go 控制流]]