errors.Is用于判断错误链中是否存在指定错误，它通过递归遍历错误链实现深层比较，而直接比较仅判断错误实例是否相同；自定义错误可通过实现Is方法支持errors.Is；errors.As则用于判断并提取特定类型的错误；错误链过长理论上影响性能但实际可忽略；在测试中使用errors.Is可更可靠地验证错误。
Golang的
errors.Is函数，简单来说，就是用来判断一个错误是不是在另一个错误链里面。它会沿着错误链向上查找，直到找到匹配的错误，或者到达链的末端。
解决方案
errors.Is函数是 Go 1.13 引入的，用于更方便地检查错误链中是否存在特定类型的错误。它的基本用法如下：
package main
import (
"errors"
"fmt"
)
var ErrNotFound = errors.New("not found")
func main() {
err := someFunction()
if errors.Is(err, ErrNotFound) {
fmt.Println("资源未找到")
} else if err != nil {
fmt.Println("其他错误:", err)
}
}
func someFunction() error {
// 模拟一个可能返回 ErrNotFound 的函数
return fmt.Errorf("操作失败: %w", ErrNotFound)
}在这个例子中，
errors.Is函数会检查
someFunction返回的错误链中是否包含
ErrNotFound错误。
fmt.Errorf("%w", err) 这种写法是 Go 1.13 引入的错误包装方式，它创建了一个包含原始错误的新的错误，形成了错误链。errors.Is会递归地检查这个链，直到找到匹配的错误或链的末端。
立即学习“go语言免费学习笔记（深入）”；
副标题1： errors.Is 与直接比较的区别是什么？
直接比较（
err == ErrNotFound）只能判断两个错误是否是完全相同的实例。而
errors.Is能够沿着错误链向上查找，即使错误被包装了多次，也能找到原始的错误。举个例子：
package main
import (
"errors"
"fmt"
)
var ErrNotFound = errors.New("not found")
func main() {
err := fmt.Errorf("wrapper: %w", ErrNotFound)
// 直接比较
if err == ErrNotFound {
fmt.Println("直接比较：相等") // 不会执行
} else {
fmt.Println("直接比较：不相等") // 会执行
}
// 使用 errors.Is
if errors.Is(err, ErrNotFound) {
fmt.Println("errors.Is：相等") // 会执行
} else {
fmt.Println("errors.Is：不相等")
}
}可以看到，直接比较失败了，因为
err实际上是一个包装了
ErrNotFound的新错误。而
errors.Is成功地找到了链中的
ErrNotFound。
副标题2： 如何自定义错误类型并使用 errors.Is 进行判断？
你可以自定义错误类型，并让
errors.Is能够识别它们。这需要你的自定义错误类型实现
Is(error) bool方法。例如：
package main
import (
"errors"
"fmt"
)
type MyError struct {
Code int
Message string
}
func (e *MyError) Error() string {
return fmt.Sprintf("Code: %d, Message: %s", e.Code, e.Message)
}
func (e *MyError) Is(target error) bool {
t, ok := target.(*MyError)
if !ok {
return false
}
return e.Code == t.Code
}
var ErrMyError = &MyError{Code: 100, Message: "My Custom Error"}
func main() {
err := fmt.Errorf("wrapped: %w", ErrMyError)
if errors.Is(err, &MyError{Code: 100, Message: ""}) {
fmt.Println("errors.Is 匹配 MyError") // 会执行
} else {
fmt.Println("errors.Is 不匹配 MyError")
}
}在这个例子中，
MyError实现了
Is方法。当
errors.Is遇到
MyError类型的错误时，会调用这个方法进行比较。注意，
Is方法的实现需要仔细考虑，确保逻辑正确。这里我们只比较了
Code字段，你可以根据实际需求进行调整。
副标题3： errors.As 函数的作用是什么？它和 errors.Is 有什么区别？
errors.As函数用于判断错误链中是否存在特定 类型 的错误，并将错误赋值给一个变量。它的用法如下：
package main
import (
"errors"
"fmt"
)
type MyError struct {
Code int
Message string
}
func (e *MyError) Error() string {
return fmt.Sprintf("Code: %d, Message: %s", e.Code, e.Message)
}
func main() {
var myErr *MyError
err := fmt.Errorf("wrapped: %w", &MyError{Code: 200, Message: "Another Error"})
if errors.As(err, &myErr) {
fmt.Printf("找到 MyError, Code: %d, Message: %s\n", myErr.Code, myErr.Message) // 会执行
} else {
fmt.Println("未找到 MyError")
}
}errors.Is检查错误链中是否存在 特定值 的错误，而
errors.As检查是否存在 特定类型 的错误，并将错误赋值给一个变量。简单来说，
errors.Is用于比较错误的值，
errors.As用于提取错误类型。
errors.As需要传递一个指向目标类型的指针，如果错误链中存在该类型的错误，则会将错误赋值给该指针。
副标题4： 错误链过长会影响 errors.Is 的性能吗？
理论上，错误链越长，
errors.Is需要遍历的次数就越多，性能也会受到一定影响。但实际上，错误链的长度通常不会很长，所以这种影响通常可以忽略不计。不过，在设计错误处理机制时，还是应该尽量避免创建过长的错误链。一种优化策略是，在错误链的适当位置，对错误进行处理或转换，避免错误一直向上冒泡。
副标题5： 如何在测试中使用 errors.Is 来验证错误？
在测试中，
errors.Is可以用来验证函数是否返回了预期的错误。例如：
package main
import (
"errors"
"testing"
)
var ErrTest = errors.New("test error")
func MyFunc() error {
return ErrTest
}
func TestMyFunc(t *testing.T) {
err := MyFunc()
if !errors.Is(err, ErrTest) {
t.Errorf("expected ErrTest, got %v", err)
}
}这种方式比直接比较错误更健壮，因为即使错误被包装了，测试仍然能够通过。
