Go-06-错误处理、panic、recover 与日志

2026-08-27

字数统计: 1.6k字 | 阅读时长≈ 7分

Go-06-错误处理、panic、recover 与日志

本节目标：掌握 Go 的错误处理哲学（error 是值不是异常），理解 panic/recover 用法，熟练用 log/slog 记录日志。

1. 错误是值（error is a value）

Go 的哲学：错误是普通的返回值，不是控制流。

// error 是内置接口
type error interface {
    Error() string
}

// 标准错误创建
var ErrNotFound = errors.New("not found")

// 带格式化的错误
err := fmt.Errorf("user %s not found", username)

// 包装错误（%w 保留原 error，可被 errors.Is/As 检查）
err := fmt.Errorf("open file %s: %w", path, os.ErrNotExist)

2. 错误处理惯用法

f, err := os.Open(path)
if err != nil {
    return err   // 错误向上抛
}
defer f.Close()

// 错误处理模板
result, err := doSomething()
if err != nil {
    if errors.Is(err, ErrNotFound) {
        // 处理 not found
    } else {
        return fmt.Errorf("doSomething failed: %w", err)
    }
}

3. errors.Is 和 errors.As（Go 1.13+）

**errors.Is**：判断错误链中是否包含某个特定错误

_, err := os.Open("missing.txt")
if errors.Is(err, os.ErrNotExist) {
    fmt.Println("文件不存在")
}

// 自定义错误
var ErrPermission = errors.New("permission denied")
if errors.Is(err, ErrPermission) {
    // ...
}

**errors.As**：从错误链中提取特定类型的错误

type MyError struct {
    Code int
    Msg  string
}
func (e *MyError) Error() string { return e.Msg }

// 错误链：*MyError 被 wrap 在某个地方
var target *MyError
if errors.As(err, &target) {
    fmt.Println("code:", target.Code)
}

fmt.Errorf 用 %w 包装（必须用 %w，不是 %v 或 %s）：

if err != nil {
    return fmt.Errorf("read config: %w", err)
    //              ^ %w 保留可 unwrap 的错误
}

4. 自定义错误类型

type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation failed: field=%s msg=%s", e.Field, e.Message)
}

// 使用
func validateUser(u User) error {
    if u.Name == "" {
        return &ValidationError{Field: "Name", Message: "cannot be empty"}
    }
    if u.Age < 0 {
        return &ValidationError{Field: "Age", Message: "must be non-negative"}
    }
    return nil
}

// 调用方处理
err := validateUser(u)
var ve *ValidationError
if errors.As(err, &ve) {
    fmt.Printf("字段 %s 校验失败: %s\n", ve.Field, ve.Message)
}

5. panic 和 recover

panic：运行时错误，正常代码不应该主动调用。
recover：在 defer 里调用，能”抓住” panic，让程序不崩溃。

func mayPanic() {
    panic("出事了")
}

func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("recovered from:", r)
        }
    }()
    mayPanic()  // 会 panic
    fmt.Println("这行不会执行")
}

func main() {
    safeCall()
    fmt.Println("程序继续运行")
}
// 输出：
// recovered from: 出事了
// 程序继续运行

应该 panic 的场景：

程序员的 bug（数组越界、空指针解引用）→ Go runtime 自动 panic
“不可能发生”的状态（如配置缺失、init 失败）
框架初始化时的不可恢复错误

不应该 panic 的场景：

用户输入错误 → 返回 error
文件不存在 → 返回 error
网络超时 → 返回 error
可预期的失败 → 永远用 error

最佳实践：

// 反例：把可恢复错误当 panic
func MustParseURL(s string) *url.URL {
    u, err := url.Parse(s)
    if err != nil {
        panic(err)  // 调用方没法处理！
    }
    return u
}

// 正例：返回 error
func ParseURL(s string) (*url.URL, error) {
    return url.Parse(s)
}

6. 实战：重试机制

func retry(attempts int, sleep time.Duration, fn func() error) error {
    var err error
    for i := 0; i < attempts; i++ {
        if err = fn(); err == nil {
            return nil
        }
        time.Sleep(sleep)
    }
    return fmt.Errorf("after %d attempts: %w", attempts, err)
}

// 用法
err := retry(3, time.Second, func() error {
    return doHTTPRequest()
})

7. 用 sentinel 错误 vs 自定义类型

// 简单场景：sentinel
var (
    ErrNotFound   = errors.New("not found")
    ErrPermission = errors.New("permission denied")
)

// 携带上下文：自定义类型
type HTTPError struct {
    StatusCode int
    URL        string
    Body       string
}
func (e *HTTPError) Error() string {
    return fmt.Sprintf("HTTP %d for %s", e.StatusCode, e.URL)
}

8. 日志：log/slog（Go 1.21+ 推荐）

旧 log 包功能有限，**新项目都用 log/slog**（结构化日志）：

import "log/slog"

// 默认文本 logger
slog.Info("user login", "user", "alice", "ip", "192.168.1.1")
// 输出：2026/06/09 10:23:45 INFO user login user=alice ip=192.168.1.1

slog.Debug("debug info")        // 默认不输出
slog.Warn("warning")
slog.Error("failed", "err", err)

JSON 格式（生产环境推荐）：

handler := slog.NewJSONHandler(os.Stderr, nil)
logger := slog.New(handler)
slog.SetDefault(logger)

slog.Info("request",
    "method", "GET",
    "path", "/api/users",
    "status", 200,
    "duration_ms", 42,
)
// 输出：{"time":"2026-06-09T10:23:45Z","level":"INFO","msg":"request","method":"GET",...}

带 logger 的 context：

logger := slog.With("request_id", "abc123")
logger.Info("processing")  // 自动带上 request_id

// 在 handler 里设置全局属性
handler := slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{
    Level: slog.LevelDebug,  // 显示 DEBUG 级别
    AddSource: true,         // 添加源码位置
})

第三方日志库（如果需要更强大）：

uber-go/zap：性能最佳
rs/zerolog：零分配
sirupsen/logrus：老牌但已停止维护

9. 实战：HTTP 服务端统一错误处理

func writeError(w http.ResponseWriter, err error) {
    var ve *ValidationError
    if errors.As(err, &ve) {
        http.Error(w, ve.Error(), http.StatusBadRequest)
        slog.Warn("validation failed", "field", ve.Field, "err", err)
        return
    }
    if errors.Is(err, ErrNotFound) {
        http.Error(w, "not found", http.StatusNotFound)
        return
    }
    // 兜底
    http.Error(w, "internal server error", http.StatusInternalServerError)
    slog.Error("unhandled error", "err", err)
}

func handleRequest(w http.ResponseWriter, r *http.Request) {
    user, err := getUser(r.URL.Query().Get("id"))
    if err != nil {
        writeError(w, err)
        return
    }
    json.NewEncoder(w).Encode(user)
}

10. 调试技巧

runtime/debug 打印堆栈：

import "runtime/debug"

func process() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("panic:", r)
            debug.PrintStack()  // 打印堆栈
        }
    }()
    // ...
}

go vet 静态检查：

1 2	go vet ./... # 能发现：printf 格式错误、错误的 mutex 复制、reachable code 等

delve 调试器（推荐学习）：

1 2	go install github.com/go-delve/delve/cmd/dlv@latest dlv debug main.go

小结

概念	用法	哲学
`error`	普通返回值	显式处理，不要忽略
`errors.Is`	判断错误类型	检查错误链
`errors.As`	提取错误实例	拿到错误细节
`%w`	包装错误	永远用 %w 不要 %v
`panic`	不可恢复错误	宁可 crash 也不要数据错乱
`recover`	在 defer 里”挽救”	只在必须时才用
`slog`	结构化日志	字段值是结构化的，便于查询

核心原则：

错误是预期的一部分，用 error 返回
panic 是程序员的 bug或不可恢复的初始化错误
日志要带上下文（request_id、user_id）
错误要层层包装（%w），但不要丢失原始信息

下一节讲单元测试和 TDD，这是 Go 工具链最值得称赞的部分。

本文作者： CoderSong
本文链接： https://jack-song-gif.github.io/2026/08/27/Go-06-错误处理、panic与日志/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！