0%

如何优雅的处理Golang错误

在看《Go入门指南》的一种用闭包处理错误的模式时,里面提到了一种错误的优雅处理方式,减少我们重复写if err:=f(); err != nil{}式的代码,感觉很心动,做了下测试,结论如下:

  1. 能减少if err式的代码,代码可以变清新整洁。
  2. 使用存在限制:只有当错误需要结束调用时才可以使用这种方法,如果被调用函数返回错误,但调用者函数需处理错误后,向下继续执行,则不能采用这种方法。

经常的写法

我们在设计函数时,错误处理要遵循以下2个规则:

  1. 被调用函数如果有错误,需要传递给调用者,一定要返回
  2. 调用者收到返回的错误,一定不可忽视,忽视就是埋bug。如果调用者不处理,被调函数就需要设计成无错误返回。

我们都有这种感受,一个函数需要调用许多函数,然后处理他们的错误,光if err就写了一堆,比如下面的test()函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package main

import (
"errors"
"log"
)

func main() {
test()
}

func test() {
if err := a(); err != nil {
log.Println(err)
}

if err := b(); err != nil {
log.Println(err)
}

if _, err := c(1, 0); err != nil {
log.Println(err)
}

if _, err := d(1, 0); err != nil {
log.Println(err)
}
}

func a() error {
return errors.New("error in a")
}

func b() error {
return errors.New("error in b")
}

func c(x, y int) (int, error) {
return x + y, errors.New("error in c")
}

func d(x, y int) (int, error) {
if y == 0 {
return 0, errors.New("error in d, divided by 0")
}
return x / y, nil
}

测试输出:

1
2
3
4
2018/10/24 14:42:40 error in a
2018/10/24 14:42:40 error in b
2018/10/24 14:42:40 error in c
2018/10/24 14:42:40 error in d, divided by 0

优雅的方式

借用2个小工具:

  1. check函数,把错误转化为panic
  2. 函数在defer中增加错误处理,从panic中恢复错误,并打印

我们对test()函数进行小小的改造。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package main

import (
"errors"
"fmt"
)

func main() {
test()
}

func test() {
defer func() {
if r := recover(); r != nil {
log.Println("got error: ", r)
}
}()

var err error
err = a()
check(err)

err = b()
check(err)

_, err = c(1, 2)
check(err)

_, err = d(1, 0)
check(err)
}

func check(err error) {
if err != nil {
panic(err)
}
}

func a() error {
return errors.New("error in a")
}

func b() error {
return errors.New("error in b")
}

func c(x, y int) (int, error) {
return x + y, errors.New("error in c")
}

func d(x, y int) (int, error) {
if y == 0 {
return 0, errors.New("error in d, divided by 0")
}
return x / y, nil
}

输出结果:

1
2018/10/24 17:29:35 got error:  error in a

test()函数是清爽了不少,也不用一直if然后处理err了,但是这种处理把错误转化为panic,导致test()后续的代码无法再继续执行,b(), c(), d()几个函数就没法执行了。

所以如果test()函数,遇到错误后就返回,就很适合这种优雅的方式。

还可以更优雅吗

test()函数中的defer看着挺碍眼的,我们还能让test()更简洁点吗,代码再优雅点?

采用文章中介绍的办法,增加errorHandler()函数,实现对被调用函数的封装,为它增加defer函数,恢复panic报的错误,看代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package main

import (
"errors"
"log"
)

func main() {
errorHandler(test)()
}

func test() {
var err error
err = a()
check(err)

err = b()
check(err)

_, err = c(1, 2)
check(err)

_, err = d(1, 0)
check(err)
}

func check(err error) {
if err != nil {
panic(err)
}
}

// 封装f:为传入的函数增加defer
func errorHandler(f func()) func() {
return func() {
defer func() {
if r := recover(); r != nil {
log.Println("got error: ", r)
}
}()

f()
}
}

func a() error {
return errors.New("error in a")
}

func b() error {
return errors.New("error in b")
}

func c(x, y int) (int, error) {
return x + y, errors.New("error in c")
}

func d(x, y int) (int, error) {
if y == 0 {
return 0, errors.New("error in d, divided by 0")
}
return x / y, nil
}

结果:

1
2018/10/24 17:36:41 got error:  error in a

还能再一次优雅吗

errorHandler()函数不够通用,它只接受无入参,无返回的函数。

  1. 如果这篇文章对你有帮助,不妨关注下我的Github,有文章会收到通知。
  2. 本文作者:大彬
  3. 如果喜欢本文,随意转载,但请保留此原文链接:http://lessisbetter.site/2018/10/24/go-handle-error/

欢迎关注我的其它发布渠道