Go语言中实现打印堆栈的errors包的用法详解

目录

• Go语言打印堆栈errors包
• 1、安装
• 2、使用
• 2.1 New()函数
• 2.2 WithMessage()函数
• 2.3 WithStack()
• 2.4 Wrap()函数
• 3、总结

Go语言打印堆栈errors包

因为Go语言提供的错误太简单了，以至于简单的我们无法更好的处理问题，甚至不能为我们处理错误，提供更有用的信息，所以诞生了很多对错误处理的库，github.com/pkg/errors是比较简洁的一样，并且功能非常强大，受到了大量开发者的欢迎，使用者很多。

1、安装

go get github.com/pkg/errors

2、使用

跟踪堆栈信息的函数使用：

// 新生成一个错误, 带堆栈信息
func New(message string) error
//只附加新的信息
func WithMessage(err error, message string) error
//只附加调用堆栈信息
func WithStack(err error) error
//同时附加堆栈和信息
func Wrap(err error, message string) error

打印出堆栈信息：

// 功能一样，输出错误信息，不包含堆栈
%s,%v 
// 输出的错误信息带引号，不包含堆栈
%q 
// 输出错误信息和堆栈
%+v 
//如：
fmt.Println(fmt.Sprintf("%s", err))
fmt.Println(fmt.Sprintf("%q", err))
fmt.Println(fmt.Sprintf("%+v", err))

2.1 New()函数

它的使用非常简单，如果我们要新生成一个错误，可以使用 New 函数生成错误，自带调用堆栈信息。

// 例子
package main
import (
	"fmt"
	"github.com/pkg/errors"
)
func main() {
	result, err := Divide(10, 0)
	if err != nil {
		fmt.Println(fmt.Sprintf("error1: %v", err))
		fmt.Println(fmt.Sprintf("error2: %s", err))
		fmt.Println(fmt.Sprintf("error3: %q", err))
		fmt.Println(fmt.Sprintf("error4: %+v", err))
	} else {
		fmt.Println("result:", result)
	}
}
func Divide(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("division can not 0")
	} else {
		return a / b, nil
	}
}

程序输出

error1: division can not 0
error2: division can not 0
error3: "division can not 0"
error4: division can not 0
main.Divide
        C:/Users/admin/Desktop/gg/new/go-errors/001.go:23
main.main
        C:/Users/admin/Desktop/gg/new/go-errors/001.go:10
runtime.main
        D:/install/go1.18.4/src/runtime/proc.go:250
runtime.goexit
        D:/install/go1.18.4/src/runtime/asm_amd64.s:1571

如果有一个现成的 error，我们需要对他进行再次包装处理，这时候有三个函数可以选择。

//只附加新的信息
func WithMessage(err error, message string) error
//只附加调用堆栈信息
func WithStack(err error) error
//同时附加堆栈和信息
func Wrap(err error, message string) error

2.2 WithMessage()函数

// 例子
package main
import (
	"fmt"
	"github.com/pkg/errors"
)
func main() {
	result, err := Divide(10, 0)
	if err != nil {
		fmt.Println(fmt.Sprintf("error1: %v", err))
		fmt.Println(fmt.Sprintf("error2: %s", err))
		fmt.Println(fmt.Sprintf("error3: %q", err))
		fmt.Println(fmt.Sprintf("error4: %+v", err))
	} else {
		fmt.Println("result:", result)
	}
}
func Divide(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.WithMessage(errors.New("division can not 0"),"func Divide(a, b int) (int, error) {}")
	} else {
		return a / b, nil
	}
}

程序输出

error1: func Divide(a, b int) (int, error) {}: division can not 0
error2: func Divide(a, b int) (int, error) {}: division can not 0
error3: func Divide(a, b int) (int, error) {}: division can not 0
error4: division can not 0
main.Divide
        C:/Users/admin/Desktop/gg/new/go-errors/002.go:23
main.main
        C:/Users/admin/Desktop/gg/new/go-errors/002.go:10
runtime.main
        D:/install/go1.18.4/src/runtime/proc.go:250
runtime.goexit
        D:/install/go1.18.4/src/runtime/asm_amd64.s:1571
func Divide(a, b int) (int, error) {}

2.3 WithStack()

// 例子
package main
import (
	"fmt"
	"github.com/pkg/errors"
)
func main() {
	result, err := Divide(10, 0)
	if err != nil {
		fmt.Println(fmt.Sprintf("error1: %v", err))
		fmt.Println(fmt.Sprintf("error2: %s", err))
		fmt.Println(fmt.Sprintf("error3: %q", err))
		fmt.Println(fmt.Sprintf("error4: %+v", err))
	} else {
		fmt.Println("result:", result)
	}
}
func Divide(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.WithStack(errors.New("division can not 0"))
	} else {
		return a / b, nil
	}
}

程序输出

error1: division can not 0
error2: division can not 0
error3: "division can not 0"
error4: division can not 0
main.Divide
        C:/Users/admin/Desktop/gg/new/go-errors/003.go:23
main.main
        C:/Users/admin/Desktop/gg/new/go-errors/003.go:10
runtime.main
        D:/install/go1.18.4/src/runtime/proc.go:250
runtime.goexit
        D:/install/go1.18.4/src/runtime/asm_amd64.s:1571
main.Divide
        C:/Users/admin/Desktop/gg/new/go-errors/003.go:23
main.main
        C:/Users/admin/Desktop/gg/new/go-errors/003.go:10
runtime.main
        D:/install/go1.18.4/src/runtime/proc.go:250
runtime.goexit
        D:/install/go1.18.4/src/runtime/asm_amd64.s:1571

2.4 Wrap()函数

// 例子
package main
import (
	"fmt"
	"github.com/pkg/errors"
)
func main() {
	result, err := Divide(10, 0)
	if err != nil {
		fmt.Println(fmt.Sprintf("error1: %v", err))
		fmt.Println(fmt.Sprintf("error2: %s", err))
		fmt.Println(fmt.Sprintf("error3: %q", err))
		fmt.Println(fmt.Sprintf("error4: %+v", err))
	} else {
		fmt.Println("result:", result)
	}
}
func Divide(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.Wrap(errors.New("division can not 0"),"func Divide(a, b int) (int, error){}")
	} else {
		return a / b, nil
	}
}

程序输出

error1: func Divide(a, b int) (int, error){}: division can not 0
error2: func Divide(a, b int) (int, error){}: division can not 0
error3: "func Divide(a, b int) (int, error){}: division can not 0"
error4: division can not 0
main.Divide
        C:/Users/admin/Desktop/gg/new/go-errors/004.go:23
main.main
        C:/Users/admin/Desktop/gg/new/go-errors/004.go:10
runtime.main
        D:/install/go1.18.4/src/runtime/proc.go:250
runtime.goexit
        D:/install/go1.18.4/src/runtime/asm_amd64.s:1571
func Divide(a, b int) (int, error){}
main.Divide
        C:/Users/admin/Desktop/gg/new/go-errors/004.go:23
main.main
        C:/Users/admin/Desktop/gg/new/go-errors/004.go:10
runtime.main
        D:/install/go1.18.4/src/runtime/proc.go:250
runtime.goexit
        D:/install/go1.18.4/src/runtime/asm_amd64.s:1571

这里只是简单介绍相关函数的使用，我们可以自己对这些函数进行封装，然后在相应的地方进行调用。

3、总结

通过使用这个 github.com/pkg/errors 错误库，我们可以收集更多的信息，可以让我们更容易的定位问题。

我们收集的这些信息不止可以输出到控制台，也可以当做日志，使用输出到相应的 Log 日志里，便于分析问题。

以上就是Go语言中实现打印堆栈的errors包的用法详解的详细内容，更多关于Go语言打印堆栈errors包的资料请关注其它相关文章！