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: %sn", 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) } }
这种方式比直接比较错误更健壮，因为即使错误被包装了，测试仍然能够通过。
评论（已关闭）
评论已关闭