Go 语言 error 接口:返回错误信息
一、概述
在 Go 语言中,error 是一个内置的接口,用于表示函数、方法运行时的错误信息。通过实现 error 接口,可以自定义错误类型,用来传递错误信息。
本文将介绍 Go 语言中的 error 接口及其使用方法,主要内容包括
- error 接口原理
- error 接口实现
- 创建错误
- 处理错误
- 自定义错误类型
- 封装错误
- 错误比较
- 错误检查
- 错误包装
- 最佳实践
- 应用场景
希望本文可以帮助你深入理解 Go 语言的 error 接口,在实际项目中合理运用。（文中有广告，忍一下哈，原创不易，cpu给我干烧了）
二、error 接口原理
error 是一个内置接口,定义如下
package main import ( "fmt" "github.com/pkg/errors" ) func readConfig() error { // 模拟读取配置文件时发生的错误 return errors.New("config file not found") } func main() { err := readConfig() if err != nil { // 使用 errors.Wrap 包装错误，并添加上下文信息 err = errors.Wrap(err, "read config failed") fmt.Println(err) } }
它包含一个方法 Error() string,返回错误信息。
任何实现了该接口的类型都可以作为 error 返回。
三、error 接口实现
实现 error 接口很简单,只需要实现 Error() string 方法，就可以用 ParseError 作为 error 返回。
package main import ( "fmt" ) // 自定义错误类型 type ParseError struct { Filename string Line int } // 实现 error 接口 func (e *ParseError) Error() string { return fmt.Sprintf("parse error in %s:%d", e.Filename, e.Line) } func main() { // 用法 err := &ParseError{"main.go", 10} fmt.Println(err) // 输出: parse error in main.go:10 }
四、创建错误
Go 语言内置函数可以创建错误，也可以从自定义错误类型创建错误。
package main import ( "errors" "fmt" ) // 自定义错误类型 type ParseError struct { Filename string Line int } // 实现 error 接口 func (e *ParseError) Error() string { return fmt.Sprintf("parse error in %s:%d", e.Filename, e.Line) } func main() { // 使用 errors.New 创建错误 err1 := errors.New("unexpected error") fmt.Println("err1:", err1) // 使用 fmt.Errorf 创建错误 filename := "main.go" err2 := fmt.Errorf("read %s failed", filename) fmt.Println("err2:", err2) // 从自定义错误类型创建错误 err3 := &ParseError{"main.go", 10} fmt.Println("err3:", err3) // 检查错误类型并处理 if err1 != nil { fmt.Println("Error 1:", err1) } if err2 != nil { fmt.Println("Error 2:", err2) } if err3 != nil { fmt.Println("Error 3:", err3) } }
五、处理错误
通过多种方式处理错误
package main import ( "errors" "fmt" ) // 模拟一个可能返回错误的函数 func fn() (int, error) { return 0, errors.New("an error occurred") } func main() { // 示例1: 使用 if 处理错误 _, err1 := fn() if err1 != nil { fmt.Println("Error 1:", err1) return } // 示例2: 忽略错误 _, _ = fn() // 示例3: 传递错误并添加上下文信息 _, err3 := fn() if err3 != nil { err3 = fmt.Errorf("read config failed: %w", err3) fmt.Println("Error 3:", err3) return } }
六、自定义错误类型
可以通过自定义错误类型传递更多信息:
package main import ( "fmt" ) // 自定义错误类型 type ArgError struct { Arg int Prob string } // 实现 Error() 方法 func (e *ArgError) Error() string { return fmt.Sprintf("%d - %s", e.Arg, e.Prob) } func main() { // 创建一个 ArgError 类型的错误值 err := &ArgError{Arg: 42, Prob: "invalid argument"} // 打印错误信息 fmt.Println(err.Error()) }
七、封装错误
可以通过封装隐藏底层错误细节，上层只会看到 ServiceError。
package main import ( "errors" "fmt" ) // 定义 ServiceError 类型 type ServiceError struct { Message string Err error } // 实现 Error() 方法 func (se ServiceError) Error() string { return fmt.Sprintf("%s: %v", se.Message, se.Err) } // 函数 serviceError 接受一个错误 // 并返回一个 ServiceError 类型的错误 func serviceError(err error) error { return &ServiceError{ Message: "server failed", Err: err, } } func main() { // 创建一个普通错误 originalError := errors.New("original error") // 使用 serviceError 函数转换为 ServiceError 类型的错误 serviceErr := serviceError(originalError) // 打印错误信息 fmt.Println(serviceErr.Error()) }
八、错误比较
可以使用 errors.Is()判断两个错误是否相等
package main import ( "errors" "fmt" ) var ErrNotFound = errors.New("not found") func main() { // 创建一个自定义错误 err := fmt.Errorf("custom error: %w", ErrNotFound) // 使用 errors.Is 检查错误是否为 ErrNotFound if errors.Is(err, ErrNotFound) { fmt.Println("ErrNotFound found") } else { fmt.Println("ErrNotFound not found") } }
九、错误检查
errors.As()可以检测具体错误类型
package main import ( "errors" "fmt" ) type ArgError struct { Arg int Prob string } func (e ArgError) Error() string { return fmt.Sprintf("%d - %s", e.Arg, e.Prob) } func main() { // 创建一个自定义错误 err := ArgError{Arg: 42, Prob: "invalid argument"} // 尝试将错误转换为 error 类型 var e error if errors.As(err, &e) { fmt.Println("Conversion successful") // 输出整个错误消息 fmt.Println(e.Error()) } else { fmt.Println("Conversion failed") } }
十、错误包装
errors.Wrap()可以包装错误
package main import ( "fmt" "github.com/pkg/errors" ) func readConfig() error { // 模拟读取配置文件时发生的错误 return errors.New("config file not found") } func main() { err := readConfig() if err != nil { // 使用 errors.Wrap 包装错误，并添加上下文信息 err = errors.Wrap(err, "read config failed") fmt.Println(err) } }
十一、最佳实践
错误处理的一些最佳实践
- 尽早返回错误
- 不要忽略错误
- 使用自定义错误类型
- 封装隐藏底层错误细节
- 使用 errors 包处理错误
完整实践示例
package main import ( "fmt" "os" ) // 不忽略错误 func printFileSize(filename string) error { file, err := os.Open(filename) if err != nil { return err } defer file.Close() // 获取文件大小 stat, err := file.Stat() if err != nil { return err } fmt.Printf("File size: %d bytes\n", stat.Size()) return nil } // 使用自定义错误类型 type ArgError struct { Arg int Prob string } func (e *ArgError) Error() string { return fmt.Sprintf("%d - %s", e.Arg, e.Prob) } func divide(a, b int) (int, error) { if b == 0 { return 0, &ArgError{Arg: b, Prob: "division by zero"} } return a / b, nil } // 封装底层错误 func serviceError(err error) error { return fmt.Errorf("service failed: %v", err) } func main() { // 不忽略错误 err := printFileSize("non_existent_file.txt") if err != nil { fmt.Println("Error:", err) } // 使用自定义错误类型 result, err := divide(10, 0) if err != nil { fmt.Println("Error:", err) } else { fmt.Println("Result:", result) } // 封装底层错误 baseErr := fmt.Errorf("database connection error") err = serviceError(baseErr) fmt.Println("Service Error:", err) }
十二、应用场景
error 接口常用于以下场景
- 表示函数执行错误
- 封装底层错误信息
- 传递自定义错误内容
- 比较错误信息
- 包装层层错误堆栈
完整示例
package main import ( "errors" "fmt" ) // 自定义错误内容 type SizeError struct { Size int Msg string } func (e *SizeError) Error() string { return e.Msg } // 函数执行错误 func process(arg int) error { if arg < 0 { return fmt.Errorf("invalid arg: %d", arg) } return nil } // 比较错误 func checkError(err error) { if errors.Is(err, NotFound) { fmt.Println("Error is NotFound") } else { fmt.Println("Error:", err) } } func main() { // 测试 process 函数的错误处理 err := process(-1) checkError(err) err = process(10) checkError(err) // 创建一个自定义错误 sizeErr := &SizeError{Size: 5, Msg: "size too small"} checkError(sizeErr) } var NotFound = errors.New("not found")
总结
通过讲解 error 接口的原理、实现和应用方法,希望本文可以帮助你在 Go 语言中合理处理错误。
