Golang 错误处理增强库 errorx 使用指南

errorx 是一个强大的 Golang 错误处理库，它提供了丰富的错误处理功能，包括堆栈追踪、错误包装、错误分类等特性，可以显著提升 Go 程序的错误处理能力。

安装 errorx

go get github.com/pkg/errors

注意：errorx 实际上是基于 pkg/errors 的增强版本，但概念和用法类似。

基本用法

1. 创建带堆栈的错误

package main

import (
	"fmt"
	"github.com/pkg/errors"
)

func main() {
	err := errors.New("原始错误")
	fmt.Printf("%+v\n", err)
}

输出会包含完整的堆栈信息：

原始错误
main.main
	/path/to/file.go:8
runtime.main
	...

2. 包装错误

func foo() error {
	return errors.New("foo错误")
}

func bar() error {
	err := foo()
	if err != nil {
		return errors.Wrap(err, "bar失败")
	}
	return nil
}

func main() {
	err := bar()
	if err != nil {
		fmt.Printf("%+v\n", err)
	}
}

输出会显示完整的错误链：

foo错误
main.foo
	/path/to/file.go:10
main.bar
	/path/to/file.go:14 - bar失败
main.main
	/path/to/file.go:20

高级特性

1. 错误类型判断

var ErrNotFound = errors.New("未找到")

func findUser(id int) error {
	return errors.Wrapf(ErrNotFound, "用户ID %d 未找到", id)
}

func main() {
	err := findUser(123)
	if errors.Is(err, ErrNotFound) {
		fmt.Println("确实是未找到错误")
	}
}

2. 错误解包

func main() {
	err := findUser(123)
	
	// 获取原始错误
	cause := errors.Cause(err)
	fmt.Println("原始错误:", cause)
	
	// 获取包装消息
	fmt.Println("包装消息:", err.Error())
}

3. 自定义错误类型

type MyError struct {
	Code    int
	Message string
}

func (e *MyError) Error() string {
	return fmt.Sprintf("错误码 %d: %s", e.Code, e.Message)
}

func someOperation() error {
	return &MyError{Code: 404, Message: "资源不存在"}
}

func main() {
	err := someOperation()
	var myErr *MyError
	if errors.As(err, &myErr) {
		fmt.Printf("自定义错误: 代码=%d, 消息=%s\n", myErr.Code, myErr.Message)
	}
}

实际应用示例

package main

import (
	"database/sql"
	"fmt"
	"github.com/pkg/errors"
)

var (
	ErrUserNotFound = errors.New("用户不存在")
	ErrDBFailure    = errors.New("数据库错误")
)

type User struct {
	ID   int
	Name string
}

func getUserFromDB(db *sql.DB, id int) (*User, error) {
	var user User
	err := db.QueryRow("SELECT id, name FROM users WHERE id = ?", id).Scan(&user.ID, &user.Name)
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, errors.Wrapf(ErrUserNotFound, "用户ID %d", id)
		}
		return nil, errors.Wrap(ErrDBFailure, err.Error())
	}
	return &user, nil
}

func GetUserProfile(db *sql.DB, id int) (*User, error) {
	user, err := getUserFromDB(db, id)
	if err != nil {
		return nil, errors.Wrap(err, "获取用户资料失败")
	}
	return user, nil
}

func main() {
	db, _ := sql.Open("mysql", "user:password@/dbname")
	user, err := GetUserProfile(db, 123)
	
	switch {
	case errors.Is(err, ErrUserNotFound):
		fmt.Println("处理用户不存在情况")
	case errors.Is(err, ErrDBFailure):
		fmt.Println("处理数据库错误")
	case err != nil:
		fmt.Printf("未知错误: %+v\n", err)
	default:
		fmt.Printf("用户信息: %v\n", user)
	}
}

最佳实践

1. 在应用边界处(如HTTP handler)打印完整错误日志：log.Printf("%+v", err)
2. 在内部函数间传递错误时使用Wrap添加上下文
3. 定义清晰的错误类型和错误变量
4. 使用errors.Is和errors.As进行错误类型判断
5. 避免过度包装错误，保持错误链简洁

errorx/pkgerrors 的错误处理方式已经成为 Go 社区的事实标准，它弥补了标准库errors包的不足，特别是在错误追踪和上下文传递方面。