go std errors

errors 包用于错误处理

go 中的 error 是一个要求实现 Error() string 方法的接口

// error 这个接口在 builtin 这个包中
type error interface {
	Error() string
}

go 自带一个 errorString 的结构体，默认实现了 error 这个接口

type errorString struct {
	s string
}

func (e *errorString) Error() string {
	return e.s
}

可以通过 errors 包中的 New 函数拿到一个 errorString struct 的指针

func New(text string) error {
	return &errorString{text}
}

error 基本操作

func main() {
	// 通过 errors.New 创建一个 errorString 的结构体
	// 并按照接口形式的 error 返回 New 中的字符串即为
	// errorString 的 string 类型的字段 s
	err1 := errors.New("here is a useless error")
	err2 := errors.New("here is another useless error")
	fmt.Println(err1)
	fmt.Println(err2)
	blockline()

	// 通过 fmt 包中的 Errorf 函数来对 error 进行包装 (wrap)
	// error 通过 %w 来接收 且 Errorf 接收的字符中只能有一个 %w 参数
	wrapped := fmt.Errorf("Behind is an error: %w", err1)
	fmt.Println(wrapped)
	blockline()

	// 可以通过 errors.Unwrap 通过 fmt.Errorf 包装前的 error
	// 如果传入的参数并没有包装任何的 error 那么 errors.Unwrap 返回 nil
	raw := errors.Unwrap(wrapped)
	fmt.Println(raw)

	onlyString := fmt.Errorf("No error is behind")
	fmt.Println(onlyString)
	afterUnwrap := errors.Unwrap(onlyString)
	fmt.Println(afterUnwrap)

	beyondRaw := errors.Unwrap(err2)
	fmt.Println(beyondRaw)
	blockline()

	// errors.Is 检查给定的 err 是否在指定的 err 链中
	errItem0 := errors.New("errItem0")

	errNode1 := fmt.Errorf("ErrNode1 -> %w", errItem0)
	errNode2 := fmt.Errorf("ErrNode2 -> %w", errNode1)
	errNode3 := fmt.Errorf("ErrNode3 -> %w", errNode2)
	errChain := fmt.Errorf("ErrNode4 -> %w", errNode3)

	fmt.Println(errChain)
	fmt.Println(errors.Is(errChain, errItem0))
	fmt.Println(errors.Is(errChain, errNode1))
	fmt.Println(errors.Is(errChain, errNode2))
	fmt.Println(errors.Is(errChain, errNode3))
	fmt.Println(errors.Is(errors.New("unexpected err"), errChain))
	blockline()

	// errors.As 将取出错误链中最外围的错误，并尝试转换为给定的类型
	// 如果取出的错误和给的错误类型一致，则将取出的错误复制到给的的错误中，并返回 true
	// 如果不一样，则返回 false 并且
	wild := wildError{
		n: "Jack",
		s: "wildError here!",
	}
	wildErrChain := fmt.Errorf("wildErr break the err list: %w", &wild)

	var wildErrHandler *wildError
	wildErrHandler = new(wildError)
	result := errors.As(wildErrChain, &wildErrHandler)
	fmt.Println(result)
	fmt.Println(wildErrChain)
	fmt.Println(wildErrHandler)

	var anotherTypeErr *strangeError
	anotherTypeErr = new(strangeError)
	result = errors.As(wildErrChain, &anotherTypeErr)
	fmt.Println(result)
	fmt.Println("is anotherTypeErr empty?:", (*anotherTypeErr) == strangeError{})
}

结果：

here is a useless error
here is another useless error
======================
Behind is an error: here is a useless error
======================
here is a useless error
No error is behind
<nil>
<nil>
======================
ErrNode4 -> ErrNode3 -> ErrNode2 -> ErrNode1 -> errItem0
true
true
true
true
false
======================
true
wildErr break the err list: wildError here!
wildError here!
false
is anotherTypeErr empty?: true