golang错误处理之error

golang中没有try/catch这样的异常处理机制，只能依靠返回值来做状态是否出错判断（当然它有个panic/recover机制，但一般只处理意想不到的错误）。

对于函数的返回值，惯例是最后一个参数返回error对象，来表示函数运行的状态。
如：

1. n, err := func()
2. if err != nil {
3.    ...//process error
4. }

或者写在一起

1. if n, err := func(); err != nil {
2.    ...//process error
3. }

error对象可以由errors.New()或fmt.Errorf()构造。
如：

1. var dividedErr = errors.New("Cant divided by 0")

或

1. err := fmt.Errorf("%d cant divided by 0", arg)

我们先来看看error到底是什么类型。
error在标准库中被定义为一个接口类型，该接口只有一个Error()方法：

1. type error interface {
2.   Error() string
3. }

也就是说，自定义的结构只需要拥有Error()方法，就相当于实现了error接口。


我们可以创建一个结构体，并实现Error()方法，就能根据自己的意愿构造error对象了。
如：

1. type division struct {
2.    arg int
3.    str string
4. }
6. func (e *division) Error() string {
7.    return fmt.Sprintf("%d %s", e.arg, e.str)
8. }
10. func divideCheck(arg1, arg2 int) (error) {
11.    if arg2 == 0 {
12.      return &division{arg1, "can't divided by 0"}
13.    }
14.    return nil
15. }

再来看一个例子，检查一组数据中是否有不能除（即除数为0）的情况，如果有则返回出错。
代码如下：

1. package main
3. import "fmt"
5. func divideCheck(arg1, arg2 int) (error) {
6.    if arg2 == 0 {
7.      return fmt.Errorf("%d can't divided by 0", arg1)
8.    }
9.    return nil
10. }
12. func main() {
13.    var err error
15.    err = divideCheck(4, 2)
16.    if err != nil {
17.      fmt.Println(err)
18.      return
19.   }
21.    err = divideCheck(8, 0)
22.    if err != nil {
23.      fmt.Println(err)
24.      return
25.    }
26. }

我们实现了这个功能，但是这样的代码非常不优雅，每执行一次函数调用都至少要用3行来做错误处理。

下面来优化一下。我们需要实现的功能是，只要有一个数不能除，就返回出错。那么只需要把每次检查后的状态存储到内部状态变量里，在全部处理完成后再检查这个变量就行了。
代码如下：

1. package main
3. import "fmt"
5. type division struct {
6.   err error
7. }
9. func (this *division)DivideCheck(arg1, arg2 int) {
10.   if this.err != nil {
11.     return
12.   }
13.   if arg2 == 0 {
14.     this.err = fmt.Errorf("%d can't divided by 0", arg1)
15.     return
16.   }
17. }
19. func (this *division)Err() error {
20.    return this.err
21. }
23. func main() {
24.    d := new(division)
25.    d.DivideCheck(4, 2)
26.    d.DivideCheck(8, 0)
27.    if d.Err() != nil {
28.      fmt.Println(d.Err())
29.    }
30. }

这么做代码就优雅多了，并且在每次检查前都判断内部状态是否已经出错，出错就马上返回，几乎没有性能损失。


golang的错误处理是经常被诟病的地方，但如果懂得以go的方式编程，还是可以做的挺优雅的~