GO语言基础教程（131）Go自定义错误信息之使用errors包中的New函数：Go错误处理翻车现场？用errors.New教你优雅“甩锅”！-优快云博客

一、当Go程序崩溃时，它在想什么？

还记得第一次见到的“段错误”吗？作为Gopher，我们经常和这类神秘错误打交道。但真相是：90%的运行时崩溃本可避免，而钥匙就藏在errors包里。

上周我同事小王就遭遇大型社死现场：他写的用户支付接口凌晨崩溃，排查3小时发现竟是忘了验证金额参数。当用户输入-100元时，系统居然乖乖执行了扣款！如果当时用了正确的错误处理，本可以这样优雅提示：

package main

import (
    "errors"
    "fmt"
)

func ProcessPayment(amount float64) error {
    if amount <= 0 {
        return errors.New("支付失败：金额必须是正数，你当我是ATM吗？")
    }
    // 处理支付逻辑
    return nil
}

func main() {
    if err := ProcessPayment(-100); err != nil {
        fmt.Printf("💸 交易告警：%s\n", err)
        return
    }
    fmt.Println("支付成功！")
}

输出结果：

💸 交易告警：支付失败：金额必须是正数，你当我是ATM吗？

看，一句人话错误提示，胜过千行崩溃日志！

二、 errors.New的“潜规则”你真的懂吗？

2.1 表面功夫：基础用法

官方文档说errors.New很简单：接收字符串，返回error。但你知道为什么推荐用函数而非直接创建结构体吗？

// 新手做法
type myError struct {
    msg string
}

func (e *myError) Error() string {
    return e.msg
}

// 职业玩家做法
func ValidatePhone(phone string) error {
    if len(phone) != 11 {
        return errors.New("手机号必须是11位，你这是国际长途？")
    }
    return nil
}

省了10行代码！Go哲学就是“少写代码，多做事”。而且errors.New有隐藏优化：相同内容的错误可能返回同一实例，减少内存分配。

2.2 那些年我们踩过的坑

坑1：错误信息太抽象

// 差评：程序员看了都想打人
err := errors.New("invalid input")

// 好评：产品经理都能看懂
err := errors.New("用户年龄150岁？请填写真实年龄")

坑2：忘记错误处理

// 错误示范：写了但没完全写
user, err := GetUser(123)
// 这里漏了 err != nil 检查！
user.Level = 999

建议安装errcheck工具，自动检测未处理错误。

三、实战：构建企业级错误处理体系

光会errors.New就像只会用筷子夹米饭——还得学会夹菜喝汤！来看完整示例：

package main

import (
    "errors"
    "fmt"
    "strings"
)

var (
    ErrPasswordTooShort = errors.New("密码长度至少8位")
    ErrPasswordNoDigit  = errors.New("密码必须包含数字")
    ErrPasswordNoLetter = errors.New("密码必须包含字母")
)

type RegisterRequest struct {
    Username string
    Password string
    Email    string
}

func validatePassword(pwd string) error {
    var errs []string
    
    if len(pwd) < 8 {
        errs = append(errs, ErrPasswordTooShort.Error())
    }
    
    hasDigit := false
    hasLetter := false
    for _, ch := range pwd {
        switch {
        case ch >= '0' && ch <= '9':
            hasDigit = true
        case (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'):
            hasLetter = true
        }
    }
    
    if !hasDigit {
        errs = append(errs, ErrPasswordNoDigit.Error())
    }
    if !hasLetter {
        errs = append(errs, ErrPasswordNoLetter.Error())
    }
    
    if len(errs) > 0 {
        return errors.New("密码校验失败：" + strings.Join(errs, "，"))
    }
    
    return nil
}

func RegisterUser(req RegisterRequest) error {
    if err := validatePassword(req.Password); err != nil {
        return err
    }
    
    // 其他注册逻辑
    fmt.Printf("用户%s注册成功！\n", req.Username)
    return nil
}

func main() {
    req := RegisterRequest{
        Username: "码农小明",
        Password: "123",  // 故意设置弱密码
        Email:    "xiaoming@example.com",
    }
    
    if err := RegisterUser(req); err != nil {
        fmt.Printf("❌ 注册失败：%s\n", err)
        
        // 根据错误类型提供解决方案
        if strings.Contains(err.Error(), "密码") {
            fmt.Println("💡 小提示：建议使用字母+数字组合，且长度超过8位")
        }
    }
}

运行结果：

❌ 注册失败：密码校验失败：密码长度至少8位，密码必须包含字母
💡 小提示：建议使用字母+数字组合，且长度超过8位

这个示例展示了：

预定义错误变量，方便维护
复合错误收集，一次性告诉用户所有问题
错误信息分级，核心问题+友好提示

四、进阶技巧：让错误会“说话”

4.1 错误包装：保留现场证据

Go 1.13后推出的错误包装是游戏规则改变者：

import "fmt"

func processUserData(userID int) error {
    if err := checkPermission(userID); err != nil {
        return fmt.Errorf("权限检查失败（用户%d）：%w", userID, err)
    }
    return nil
}

func checkPermission(userID int) error {
    if userID < 0 {
        return errors.New("用户ID不能为负数")
    }
    return nil
}

func main() {
    if err := processUserData(-1); err != nil {
        fmt.Println(err) // 输出：权限检查失败（用户-1）：用户ID不能为负数
        
        // 还能提取原始错误
        if underlying := errors.Unwrap(err); underlying != nil {
            fmt.Printf("根本原因：%s\n", underlying)
        }
    }
}

4.2 自定义错误类型

当需要携带更多信息时：

type ValidationError struct {
    Field   string
    Value   interface{}
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("字段%s验证失败：%s（当前值：%v）", e.Field, e.Message, e.Value)
}

func ValidateAge(age int) error {
    if age < 0 || age > 150 {
        return &ValidationError{
            Field:   "年龄",
            Value:   age,
            Message: "必须在0-150之间",
        }
    }
    return nil
}

五、性能优化：别让错误处理拖慢你的应用

在高性能场景中，频繁创建错误会影响性能。解决方案：

// 预定义错误，避免重复分配内存
var (
    ErrUserNotFound = errors.New("用户不存在")
    ErrSystemBusy  = errors.New("系统繁忙，请稍后重试")
)

// 使用错误码（适用于API）
type AppError struct {
    Code    int
    Message string
}

func (e *AppError) Error() string {
    return e.Message
}

func NewAppError(code int, msg string) *AppError {
    return &AppError{Code: code, Message: msg}
}

六、测试：如何为错误写单元测试

不会测试的错误处理等于没处理：

import "testing"

func TestValidatePassword(t *testing.T) {
    tests := []struct {
        name     string
        password string
        wantErr  bool
    }{
        {"正常密码", "Admin123", false},
        {"太短", "123", true},
        {"纯数字", "12345678", true},
        {"纯字母", "Password", true},
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            err := validatePassword(tt.password)
            if (err != nil) != tt.wantErr {
                t.Errorf("validatePassword() error = %v, wantErr %v", err, tt.wantErr)
            }
        })
    }
}