Go语言组合错误困境：errors.Wrap与fmt.Errorf的兼容问题

问题重现 #

在组合错误时，两种常见处理方式均存在不符合预期的行为：

• 使用github.com/pkg/errors.Wrap包装错误后，errors.Is无法匹配到作为上下文传入的err2；
• 使用fmt.Errorf("%w: %w", err2, errBar)包装后，errors.Cause无法返回最底层的原始错误err1。

原因拆解 #

1. errors.Wrap的本质：
   errors.Wrap(err, msg)的第二个参数是字符串类型的错误消息，并非错误实例。它仅为原始错误err添加上下文文本，不会将msg对应的错误实例纳入错误链。因此errors.Is无法从包装后的错误中匹配到err2——因为err2从未被作为错误链的一部分存储，只是把它的文本附加了进去。

2. fmt.Errorf的%w限制：
   %w动词一次只能包装一个错误实例。当连续使用两个%w时，只有最后一个会被识别为错误链的节点，前面的err2仅被当作普通文本处理（或被覆盖）。而github.com/pkg/errors.Cause会沿着错误链查找最底层错误，但错误链中只有err1被正确包装，err2并未被纳入，导致Cause返回的是整个格式化后的错误字符串，而非预期的err1。

解决方案 #

根据需求选择合适的错误组合方式：

方案1：用errors.Join组合多个错误（Go 1.20+）

如果需要同时让errors.Is匹配到多个错误，且保留错误链追踪，使用errors.Join组合多个错误实例：

errFoo := foo()
// 组合err2和包装后的err1，同时保留上下文
errFoo = errors.Join(err2, errors.Wrap(errFoo, "foo执行失败"))
fmt.Println(errors.Is(errFoo, err1)) // true
fmt.Println(errors.Is(errFoo, err2)) // true
// 若要获取最底层的err1，需遍历错误链或自定义处理

方案2：正确使用fmt.Errorf，仅包装底层错误

如果优先保证errors.Cause能拿到最底层错误，同时将err2作为上下文文本：

errBar := bar()
// 仅用%w包装底层错误err1，err2作为上下文文本
errBar = fmt.Errorf("%s: %w", err2.Error(), errBar)
fmt.Println(errors.Is(errBar, err1)) // true
fmt.Println(errors.Cause(errBar))    // err1

方案3：自定义错误类型（灵活控制匹配与溯源）

如果需要完全自定义错误的匹配（Is）和溯源（Cause）逻辑，实现自定义错误类型：

type CombinedErr struct {
    RootErr error // 最底层错误
    ContextErr error // 上下文错误
}

func (e *CombinedErr) Error() string {
    return fmt.Sprintf("%s: %s", e.ContextErr.Error(), e.RootErr.Error())
}

// 实现Unwrap支持errors.Is遍历
func (e *CombinedErr) Unwrap() []error {
    return []error{e.RootErr, e.ContextErr}
}

// 实现Is自定义匹配逻辑
func (e *CombinedErr) Is(target error) bool {
    return errors.Is(e.RootErr, target) || errors.Is(e.ContextErr, target)
}

// 实现Cause返回最底层错误
func (e *CombinedErr) Cause() error {
    return e.RootErr
}

// 使用示例
errFoo := &CombinedErr{RootErr: err1, ContextErr: err2}
fmt.Println(errors.Is(errFoo, err1)) // true
fmt.Println(errors.Is(errFoo, err2)) // true
fmt.Println(errors.Cause(errFoo))    // err1

修正后的完整代码示例 #

package main

import (
    "fmt"

    "github.com/pkg/errors"
)

var err1 = errors.New("err1")
var err2 = errors.New("err2")

func foo() error {
    return err1
}

func bar() error {
    return err1
}

type CombinedErr struct {
    RootErr    error
    ContextErr error
}

func (e *CombinedErr) Error() string {
    return fmt.Sprintf("%s: %s", e.ContextErr.Error(), e.RootErr.Error())
}

func (e *CombinedErr) Unwrap() []error {
    return []error{e.RootErr, e.ContextErr}
}

func (e *CombinedErr) Is(target error) bool {
    return errors.Is(e.RootErr, target) || errors.Is(e.ContextErr, target)
}

func (e *CombinedErr) Cause() error {
    return e.RootErr
}

func main() {
    // 方案1：errors.Join组合
    errFoo := foo()
    errFoo = errors.Join(err2, errors.Wrap(errFoo, "foo failed"))
    fmt.Println(errFoo)                  // err2: foo failed: err1
    fmt.Println(errors.Is(errFoo, err1)) // true
    fmt.Println(errors.Is(errFoo, err2)) // true
    fmt.Println(errors.Cause(errFoo))    // err2（Join的第一个错误）

    fmt.Println("*********")

    // 方案2：fmt.Errorf正确包装
    errBar := bar()
    errBar = fmt.Errorf("%s: %w", err2.Error(), errBar)
    fmt.Println(errBar)                  // err2: err1
    fmt.Println(errors.Is(errBar, err1)) // true
    fmt.Println(errors.Is(errBar, err2)) // false
    fmt.Println(errors.Cause(errBar))    // err1

    fmt.Println("*********")

    // 方案3：自定义错误类型
    errCustom := &CombinedErr{RootErr: err1, ContextErr: err2}
    fmt.Println(errCustom)                  // err2: err1
    fmt.Println(errors.Is(errCustom, err1)) // true
    fmt.Println(errors.Is(errCustom, err2)) // true
    fmt.Println(errors.Cause(errCustom))    // err1
}

内容的提问来源于stack exchange，提问作者hidayat hamir