1.error接口:
erorr是一种内建的接口类型.内建意味着不需要"import".任何包都可以直接使用,
使用起来就像int string一样自然.
源码位置:src/builtin/builtin.go
// The error built-in interface type is the conventional interface for
// representing an error condition, with the nil value representing no error.
type error interface {
Error() string
}
从源码可知.error接口只声明了一个Error()方法.任何实现了该方法的结构体都可以
作为error来使用.error的实例代表一种异常状态.Error()方法用于描述该异常状态.
值为nil的error代表没有异常.
标准库erroor包中的errorString就是实现error接口的一个例子.
源码位置:src/errors/errors.go
type errorString struct {
s string
}
func (e *errorString) Error() string {
return e.s
}
errorString是errors包的私有类型.对外不可见.只能通过相应的公开接口才可以创
建errorString实例.
2.创建error:
标准库创建方法:
1).errors.New():
源码位置:src/errors/errors.go
// New returns an error that formats as the given text.
// Each call to New returns a distinct error value even if the text is identical.
func New(text string) error {
return &errorString{text}
}
errors.New()实现比较简单.只是单纯的构建了一个errorString实例便返回了.
2).fmt.Errorf():
源码位置:src/fmt/errors.go
func Errorf(format string, a ...any) error {
p := newPrinter()
p.wrapErrs = true
p.doPrintf(format, a)
s := string(p.buf)
var err error
switch len(p.wrappedErrs) {
case 0:
err = errors.New(s)
case 1:
w := &wrapError{msg: s}
w.err, _ = a[p.wrappedErrs[0]].(error)
err = w
default:
if p.reordered {
slices.Sort(p.wrappedErrs)
}
var errs []error
for i, argNum := range p.wrappedErrs {
if i > 0 && p.wrappedErrs[i-1] == argNum {
continue
}
if e, ok := a[argNum].(error); ok {
errs = append(errs, e)
}
}
err = &wrapErrors{s, errs}
}
p.free()
return err
}
fmt.Errorf会接受两个参数然后对string进行格式化.
3.性能对比:
fmt.Errorf()适用于格式化输出错误字符串的场景.如果不需要格式化字符串.则建议
直接使用errors.New().
示例如下:
package Concurrent
import (
"errors"
"fmt"
"testing"
)
// 场景1：无格式化参数的简单错误（errors.New 原生场景 vs fmt.Errorf 无参数）
func BenchmarkErrorsNew_Simple(b *testing.B) {
// 重置计时器，排除初始化耗时
b.ResetTimer()
// 循环执行 b.N 次，b.N 由基准测试框架自动调整
for i := 0; i < b.N; i++ {
_ = errors.New("simple error")
}
}
func BenchmarkFmtErrorf_Simple(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
// fmt.Errorf 无格式化参数，等价于 errors.New
_ = fmt.Errorf("simple error")
}
}
// 场景2：带格式化参数的错误（fmt.Errorf 核心场景，errors.New 无法直接实现）
func BenchmarkFmtErrorf_Format(b *testing.B) {
// 测试参数：字符串+数字，模拟真实业务格式化场景
msg := "user"
uid := 1001
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = fmt.Errorf("user %s not found, uid: %d", msg, uid)
}
}
// 场景3：带错误包装的场景（%w 动词，fmt.Errorf 特有）
func BenchmarkFmtErrorf_Wrap(b *testing.B) {
baseErr := errors.New("base error")
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = fmt.Errorf("wrap error: %w", baseErr)
}
}
4.自定义error:
任何实现error接口的类型都可以称为error.比如标准库os中的PathError就是一个
典型的例子.
源码位置:src/io/fs.go
type PathError struct {
Op string
Path string
Err error
}
func (e *PathError) Error() string { return e.Op + " " + e.Path + ": " + e.Err.Error() }
5.异常处理:
针对error而言.异常处理包括如何检查错误 如何传递错误.
1).检查error:
最常见的检查error的方式是与nil值进行比较:
func main() {
var err error = T(5)
if err != nil {
}
}
有时也会与一些预定义的error进行比较:
package oserror
import "errors"
var (
ErrInvalid = errors.New("invalid argument")
ErrPermission = errors.New("permission denied")
ErrExist = errors.New("file already exists")
ErrNotExist = errors.New("file does not exist")
ErrClosed = errors.New("file already closed")
)
实现了error接口的类型均可以作为error来处理.也可以使用类型断言来检查error.
func AssertError(err error) {
if e,ok := err.(*os.PathError); ok {
fmt.Printf("path error: %s", e.Path)
}
}
2).传递error:
在一个函数中收到一个error.往往需要附加一些上下文信息再把error继续往上抛.
最常见的添加附加上下文信息的方法是用fmt.Errorf().
func ReturnErrorTest() {
err := errors.New("test error")
if err != nil {
fmt.Errorf("我定义的异常进行了包装%s", err)
}
}
这种方式抛出的error有一个糟糕的问题.就是原error信息和附加的信息被糅合到了
一起.示例如下:
```
import (
"fmt"
"os"
)
func WriteFile(fileName string) error {
if fileName == "测试.txt" {
return fmt.Errorf("write file error:%v", os.ErrPermission)
}
return nil
}
func ExampleWriteFile() {
err := WriteFile("测试.txt")
if err == os.ErrPermission {
fmt.Printf("write file error:%v", os.ErrPermission)
}
}
```
在这个例子中.无法明确到底是不是这个异常.为了解决这个问题.可以自定义error类
型.就像os.PathError.上下文与信息分开放.
type PathError struct {
Op string //上下文
Path string //上下文
Err error //原error
}
6.wrapError:
Go1.13针对error的优化.最核心的内容就是引入了wrapError这一新的error类型.
其他特性都是围绕此类型展开的.
源码位置:src/fmt/errors.go:
type wrapError struct {
msg string
err error
}
func (e *wrapError) Error() string {
return e.msg
}
func (e *wrapError) Unwrap() error {
return e.err
}
wrapError中的msg保存上下文信息和err.Error(). err用来存储原error.与之前的
errorString相比.还额外实现了Unwrap接口.用于返回原始的error.
7.fmt.Errorf():
fmt.Errorf()新增了格式动词%w(wrap)用于生成wrapError实例.并且兼容原有动
词格式.源码如下:
func Errorf(format string, a ...any) error {
p := newPrinter()
p.wrapErrs = true
p.doPrintf(format, a)
s := string(p.buf)
var err error
switch len(p.wrappedErrs) {
case 0:
err = errors.New(s)
case 1:
w := &wrapError{msg: s}
w.err, _ = a[p.wrappedErrs[0]].(error)
err = w
default:
if p.reordered {
slices.Sort(p.wrappedErrs)
}
var errs []error
for i, argNum := range p.wrappedErrs {
if i > 0 && p.wrappedErrs[i-1] == argNum {
continue
}
if e, ok := a[argNum].(error); ok {
errs = append(errs, e)
}
}
err = &wrapErrors{s, errs}
}
p.free()
return err
}
fmt.Errorf()将根据动词格式来动态决定生成wrapError还是errorString.
func main() {
err := errors.New("this is an error")
//使用%v
baseError := fmt.Errorf("this is a %v", err)
if _, ok := baseError.(interface{ Unwrap() error }); !ok {
fmt.Println("baseError is errorString")
}
}
使用%w格式动词生成的error类型自动变成wrapError(实现了Unwrap接口).
func main() {
err := errors.New("this is an error")
//使用%w
baseError := fmt.Errorf("this is a %w", err)
if _, ok := baseError.(interface{ Unwrap() error }); ok {
fmt.Println("baseError is wrapError")
}
}
当error在函数间传递时.error之间好像被组织成一个链式结构.
8.errors.Unwrap():
源码位置:src/errors/wrap.go
func Unwrap(err error) error {
u, ok := err.(interface {
Unwrap() error
})
if !ok {
return nil
}
return u.Unwrap()
}
如果参数err没有实现Unwrap()函数.则说明是基础error.直接返回nil.否则调用原
error实现的Unwrap函数并返回. 可以通过循环调用errors.Unwrap()方法来逐层
检查.示例如下:
func ExampleUnwrapLoop() {
err1 := fmt.Errorf("write file error:%w", os.ErrPermission)
err2 := fmt.Errorf("write file error:%w", err1)
err := err2
for {
if err == os.ErrPermission {
fmt.Printf("Permission denied\n")
break
}
if err = errors.Unwrap(err); err == nil {
break
}
}
}
9.errors.Is():
errors.Is()用于检查特定的error链中是否包含指定的error值.
源码位置:src/errors/wrap.go
func Is(err, target error) bool {
if err == nil || target == nil {
return err == target
}
isComparable := reflectlite.TypeOf(target).Comparable()
return is(err, target, isComparable)
}
func is(err, target error, targetComparable bool) bool {
for {
if targetComparable && err == target {
return true
}
if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
return true
}
switch x := err.(type) {
case interface{ Unwrap() error }:
err = x.Unwrap()
if err == nil {
return false
}
case interface{ Unwrap() []error }:
for _, err := range x.Unwrap() {
if is(err, target, targetComparable) {
return true
}
}
return false
default:
return false
}
}
}
10.errors.As()方法:
在Go1.13中.errors.As()用于从一个error链中查找是否有指定类型出现.如有.则把
error转换成该类型.
源码位置:src/errors/wrap.go
func As(err error, target any) bool {
if err == nil {
return false
}
if target == nil {
panic("errors: target cannot be nil")
}
val := reflectlite.ValueOf(target)
typ := val.Type()
if typ.Kind() != reflectlite.Ptr || val.IsNil() {
panic("errors: target must be a non-nil pointer")
}
targetType := typ.Elem()
if targetType.Kind() != reflectlite.Interface && !targetType.Implements(errorType) {
panic("errors: *target must be interface or implement error")
}
return as(err, target, val, targetType)
}
func as(err error, target any, targetVal reflectlite.Value, targetType reflectlite.Type) bool {
for {
if reflectlite.TypeOf(err).AssignableTo(targetType) {
targetVal.Elem().Set(reflectlite.ValueOf(err))
return true
}
if x, ok := err.(interface{ As(any) bool }); ok && x.As(target) {
return true
}
switch x := err.(type) {
case interface{ Unwrap() error }:
err = x.Unwrap()
if err == nil {
return false
}
case interface{ Unwrap() []error }:
for _, err := range x.Unwrap() {
if err == nil {
continue
}
if as(err, target, targetVal, targetType) {
return true
}
}
return false
default:
return false
}
}
}
山高路远.
如果大家喜欢我的分享的话.可以关注我的微信公众号
念何架构之路
