Go 语言中 errors.Is 和 errors.As 的区别
核心区别概述
errors.Is 和 errors.As 是 Go 1.13 引入的错误处理函数，它们有着不同的用途：
- errors.Is: 判断错误链中是否包含特定的错误值（错误相等性检查）
- errors.As: 尝试将错误转换为特定的错误类型（错误类型转换）——基于类型断言机制/类型选择机制
详细对比
1. 功能与目的
errors.Is:
func Is(err, target error) bool
- 检查
err错误链中是否存在与target匹配的错误 - 用于确定错误是否为某个特定的预定义错误值
- 类似于
==比较，但能穿透错误包装
errors.As:
func As(err error, target interface{
}) bool
- 尝试将
err或其包装的任何错误转换为target指向的类型 - 用于获取特定类型的错误以访问其方法或字段
- 类似于类型断言
err.(T)，但能穿透错误包装
2. 参数类型
errors.Is:
- 两个参数都是
error接口类型 - 比较两个错误值
errors.As:
- 第一个参数是
error接口 - 第二个参数是一个指向实现了
error接口的类型的指针（通常是*T，其中T实现了error）
3. 返回值含义
errors.Is:
- 返回
true: 表示错误链中包含了目标错误 - 返回
false: 表示未找到目标错误
errors.As:
- 返回
true: 表示成功找到匹配的错误类型，并已将值存入target - 返回
false: 表示未找到匹配的错误类型
实际应用示例
errors.Is 示例
package main
import (
"errors"
"fmt"
"os"
)
func main() {
// 使用预定义错误
_, err := os.Open("不存在的文件.txt")
// 检查是否为特定的错误值
if errors.Is(err, os.ErrNotExist) {
fmt.Println("文件不存在") // 这将被执行
} else {
fmt.Println("发生了其他错误:", err)
}
// 使用包装错误
err = fmt.Errorf("文件操作失败: %w", os.ErrPermission)
// 即使错误被包装，errors.Is 也能识别
if errors.Is(err, os.ErrPermission) {
fmt.Println("权限被拒绝") // 这将被执行
} else {
fmt.Println("发生了其他错误:", err)
}
}
errors.As 示例
package main
import (
"errors"
"fmt"
"os"
)
// 自定义错误类型
type DatabaseError struct {
Query string
Err error
}
func (d *DatabaseError) Error() string {
return fmt.Sprintf("数据库查询 %q 失败: %v", d.Query, d.Err)
}
// 实现 Unwrap 以支持错误包装
func (d *DatabaseError) Unwrap() error {
return d.Err
}
func queryDatabase(query string) error {
// 模拟数据库查询失败
return &DatabaseError{
Query: query,
Err: errors.New("连接超时"),
}
}
func main() {
err := queryDatabase("SELECT * FROM users")
// 使用 errors.As 获取具体错误类型
var dbErr *DatabaseError
if errors.As(err, &dbErr) {
fmt.Printf("数据库错误: 查询=%q, 原因=%v\n", dbErr.Query, dbErr.Err)
}
// 包装错误后仍能识别
wrappedErr := fmt.Errorf("操作失败: %w", err)
var pathErr *os.PathError
if errors.As(wrappedErr, &pathErr) {
fmt.Println("路径错误:", pathErr.Path)
} else {
fmt.Println("不是路径错误")
}
// 可以识别包装的原始类型
if errors.As(wrappedErr, &dbErr) {
fmt.Printf("在包装错误中找到数据库错误: 查询=%q\n", dbErr.Query)
}
}
复杂场景：多层错误包装
package main
import (
"database/sql"
"errors"
"fmt"
"os"
)
type ConfigError struct {
Field string
Err error
}
func (c *ConfigError) Error() string {
return fmt.Sprintf("配置错误 (%s): %v", c.Field, c.Err)
}
func (c *ConfigError) Unwrap() error {
return c.Err
}
func openDB() error {
// 模拟 SQL 错误
sqlErr := sql.ErrNoRows
// 第一层包装：数据库错误
dbErr := fmt.Errorf("数据库连接失败: %w", sqlErr)
// 第二层包装：配置错误
configErr := &ConfigError{
Field: "database_url",
Err: dbErr,
}
// 第三层包装：通用操作错误
return fmt.Errorf("无法初始化应用: %w", configErr)
}
func main() {
err := openDB()
// 使用 errors.Is 检查深层错误
if errors.Is(err, sql.ErrNoRows) {
fmt.Println("检测到底层 SQL 错误：没有行") // 将执行
}
// 使用 errors.As 提取特定类型
var configErr *ConfigError
if errors.As(err, &configErr) {
fmt.Printf("检测到配置错误，字段: %s\n", configErr.Field) // 将执行
}
// 对比不存在的错误
if errors.Is(err, os.ErrNotExist) {
fmt.Println("文件不存在") // 不会执行
}
var pathErr *os.PathError
if errors.As(err, &pathErr) {
fmt.Println("路径错误:", pathErr.Path) // 不会执行
}
fmt.Println("原始错误:", err)
}
自定义错误比较行为
可以通过实现 Is 和 As 方法来自定义错误的比较行为：
package main
import (
"errors"
"fmt"
)
// 自定义错误类型
type ErrorCode struct {
Code int
Message string
}
func (e *ErrorCode) Error() string {
return fmt.Sprintf("[错误 %d] %s", e.Code, e.Message)
}
// 自定义 Is 方法，只比较错误码，不比较消息
func (e *ErrorCode) Is(target error) bool {
t, ok := target.(*ErrorCode)
if !ok {
return false
}
return e.Code == t.Code
}
// 自定义 As 方法
func (e *ErrorCode) As(target interface{
}) bool {
// 特殊处理某些转换
switch t := target.(type) {
case **ErrorCode:
*t = e
return true
default:
return false
}
}
var (
ErrNotFound = &ErrorCode{
Code: 404, Message: "资源不存在"}
ErrPermission = &ErrorCode{
Code: 403, Message: "权限被拒绝"}
)
func main() {
// 创建相同代码但不同消息的错误
currentErr := &ErrorCode{
Code: 404, Message: "用户不存在"}
// 使用自定义 Is 行为
if errors.Is(currentErr, ErrNotFound) {
fmt.Println("是 404 错误") // 将执行，因为我们只比较错误码
}
if errors.Is(currentErr, ErrPermission) {
fmt.Println("是 403 错误") // 不会执行
}
// 自定义 As 行为
var targetErr *ErrorCode
if errors.As(currentErr, &targetErr) {
fmt.Printf("错误代码: %d, 消息: %s\n", targetErr.Code, targetErr.Message)
}
}
何时使用哪个函数
使用 errors.Is 的场景
-
检查错误是否为预定义的特定错误值
if errors.Is(err, io.EOF) { ... } if errors.Is(err, context.DeadlineExceeded) { ... } -
基于错误值进行条件分支
switch { case errors.Is(err, sql.ErrNoRows): // 处理数据不存在情况 case errors.Is(err, context.Canceled): // 处理取消情况 default: // 处理其他错误 }
使用 errors.As 的场景
-
需要访问特定错误类型的字段或方法
var netErr net.Error if errors.As(err, &netErr) { if netErr.Timeout() { // 处理超时特定逻辑 } } -
从错误中提取额外信息
var syntaxErr *json.SyntaxError if errors.As(err, &syntaxErr) { fmt.Printf("JSON 语法错误在位置 %d\n", syntaxErr.Offset) }
总结比较
| 特性 | errors.Is | errors.As |
|---|---|---|
| 用途 | 检查错误相等性 | 错误类型转换 |
| 与标准操作的对比 | == 的增强版 |
类型断言的增强版 |
| 第二个参数类型 | error | 指向错误类型的指针 |
| 适用场景 | 检查特定预定义错误 | 访问特定错误类型的字段/方法 |
| 自定义行为 | 通过实现 Is(error) bool |
通过实现 As(interface{}) bool |
理解这两个函数的区别对于编写健壮的 Go 错误处理代码至关重要，它们允许你在保持错误包装和传递的同时，仍能进行精确的错误类型检查和处理。