golang error处理

怼烎@ 2023-05-29 03:51 28阅读 0赞

### golang error处理 ###

*  error 是什么？
 *  存在的问题
 *  舍弃的try提案
 *  社区对于error堆栈解决方案
 *  go 1.13 的Error 升级

本文主要讲解golang中error的使用以及原理。主要包括以下话题。

*  error是什么
 *  error 面临的问题
 *  舍弃的try提案
 *  社区对于error堆栈解决方案
 *  go 1.13 对于error的提升

# error 是什么？ #

在 golang 中我们使用 error 来表示程序运行的错误。 error 是一个内建 的接口：

type error interface { 
    	Error() string
    }

很明显 error 表示那些用一个字符串就能说清的错误。

我们最常用的就是 errors.New()， 其实现非常简单:

func New(text string) error { 
    	return &errorString{ text}
    }
    
    // errorString is a trivial implementation of error.
    type errorString struct { 
    	s string
    }
    
    func (e *errorString) Error() string { 
    	return e.s
    }

用 New 函数创建出来的 error 类型实际上是 errors 包里未导出的 errorString 类型，它包含唯一的一个字段 s，并且实现了唯一的方法：Error() string。

根据 golang 的interface 的隐式实现，可以知道，任何实现了 `Error() string` 方法的对象都是隐式的实现了 error。也就是我们可以非常容易的自定义 error。

我们在使用 error 的时候，最常见的代码就是：

func main() { 
    	conent,err:=ioutil.ReadFile("file path")
    	if err !=nil{ 
    		//错误处理
    	}else { 
    		fmt.Println(string(conent))
    	}
    }

也就是golang 以返回值 error 强迫调用者对错误进行处理，要么你忽略，要么你处理（处理也可以是继续返回给调用者），对于golang这种设计方式，我们会在代码中写大量的if判断，以便做出决定。

Go 语言的多返回值使得返回错误异常简单。对于真正的异常，Go 提供 panic-recover 机制，也使得代码看起来非常简洁。

我们实际工程代码中经常自定义一些error，比如：

type fileError struct { 
    }
    
    func (fe *fileError) Error() string { 
    	return "文件错误"
    }
    
    func main() { 
    	conent, err := openFile()
    	if err != nil { 
    		fmt.Println("打开文件失败，error是：",err)
    	} else { 
    		fmt.Println(string(conent))
    	}
    }
    
    //只是模拟一个错误
    func openFile() ([]byte, error) { 
    	return nil, &fileError{ }
    }

# 存在的问题 #

前面的这种 error 处理方式看起来很简单，但是有几个很严重的问题：

1.  很容易丢失实际存储的最原始的error对象。

比如代码如下：

func a() obj, error { 
    	err := b();
    	if err != nil { 
    		return fmt.Errorf(“fail to exec call b:%v", err)
    	}
    }

这里调用a函数调用b函数时候，如果发生了error，a函数的返回实际上已经丢失了最原始的 error 对象。但是实际上我们有一些场景需要获取到最原始的error对象。

1.  没发获取到 error 发生的详细的堆栈信息：

golang里面的error里面的信息就是我们自定义的一些字符串，并没有详细的函数调用的堆栈信息(包括代码文件，行数等等)，这对于线上的 troubleshooting非常不友好。

我们知道Java里面的异常是可以嵌套的，也就是说，通过这个，我们很容易知道错误的根本原因，因为Java的异常，是一层层的嵌套返回的，不管中间经历了多少包装，我们可以通过cause找到根本错误的原因。

# 舍弃的try提案 #

golang官方曾经出现过 try-handler的提案，但是社区里面一边倒的反对声音，所以该提案被废弃了。

理由也很简单，try-catch 会让代码变得非常混乱，程序员会倾向将一些常见的错误，例如，failing to open a file，也抛到异常里，这会让错误处理更加冗长繁琐且易出错。

而 Go 语言的多返回值使得返回错误异常简单。对于真正的异常，Go 提供 panic-recover 机制，也使得代码看起来非常简洁。

# 社区对于error堆栈解决方案 #

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

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

// fundamental is an error that has a message and a stack, but no caller.
    type fundamental struct { 
    	msg string
    	*stack
    }
    
    func New(message string) error { 
    	return &fundamental{ 
    		msg:   message,
    		stack: callers(),
    	}
    }

这里的fundamental对象也是实现了 golang 内建 interface error的 Error 方法的，所以也可以认为是golang 的error。

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

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

其实上面的包装，很类似于Java的异常包装，被包装的error，其实就是Cause,在前面的章节提到错误的根本原因，就是这个Cause。所以这个错误处理库为我们提供了Cause函数让我们可以获得最原始的 error 对象。

func Cause(err error) error { 
    	type causer interface { 
    		Cause() error
    	}
    
    	for err != nil { 
    		cause, ok := err.(causer)
    		if !ok { 
    			break
    		}
    		err = cause.Cause()
    	}
    	return err
    }

使用for循环一直找到最根本（最底层）的那个error。

以上的错误我们都包装好了，也收集好了，那么怎么把他们里面存储的堆栈、错误原因等这些信息打印出来呢？其实，这个错误处理库的错误类型，都实现了Formatter接口，我们可以通过fmt.Printf函数输出对应的错误信息。

%s,%v //功能一样，输出错误信息，不包含堆栈
    %q //输出的错误信息带引号，不包含堆栈
    %+v //输出错误信息和堆栈

以上如果有循环包装错误类型的话，会递归的把这些错误都会输出。

下面是一个例子：

package main
    
    import (
    	errors2 "github.com/pkg/errors"
    )
    
    func printerr() { 
    	err := errors2.New("open file fail")
    	if err != nil { 
    		fmt.Printf("err: %+v", err)
    	}
    }
    
    func main() { 
    	printerr()
    }

输出是：

err: open file fail
    main.printerr
    	/Users/ytlou/Desktop/golang/golang_study/study/basic/errors/error_test1.go:10
    main.main
    	/Users/ytlou/Desktop/golang/golang_study/study/basic/errors/error_test1.go:29
    runtime.main
    	/usr/local/go/src/runtime/proc.go:203
    runtime.goexit
    	/usr/local/go/src/runtime/asm_amd64.s:1357

这里有一点需要特别注意的，一定要使用 Printf 来输出，并且加上`%+v`, 这里多了一个 `+` 符号。

# go 1.13 的Error 升级 #

go1.13的升级中，对内置的error进行了增强，提供了 Error Wrapper 的功能。

数据结构就是：

///usr/local/go/src/fmt/errors.go
    type wrapError struct { 
    	msg string
    	err error
    }

提供的就是对 error 的一层包装。此外新的版本还提供了一些便利方法：

func Errorf(format string, a ...interface{ }) error 
    使用实例：fmt.Errorf("wrap err1：%w", err1)
    
    // 获取被 wrap 的error
    errors.Unwrap(w)
    
    //如果err和target是同一个，那么返回true
    //如果err 是一个wrap error,target也包含在这个嵌套error链中的话，那么也返回true。
    func Is(err, target error) bool
    
    //从功能上来看，As所做的就是遍历err嵌套链，从里面找到类型符合的error，然后把这个error赋予target,这样我们就可以使用转换后的target了，这里有值得赋予，所以target必须是一个指针。
    func As(err error, target interface{ }) bool

具体详细的实现就不解释了，整体来说和 `github.com/pkg/errors` 比较像，但是没有堆栈信息，所以目前来说，我还是偏向于使用`github.com/pkg/errors`。 但是我相信在 **go2** 中会有新的升级。