在看《Go入门指南》的一种用闭包处理错误的模式时，里面提到了一种错误的优雅处理方式，减少我们重复写if err:=f(); err != nil{}式的代码，感觉很心动，做了下测试，结论如下：
- 能减少
if err式的代码，代码可以变清新整洁。
- 使用存在限制：只有当错误需要结束调用时才可以使用这种方法，如果被调用函数返回错误，但调用者函数需处理错误后，向下继续执行，则不能采用这种方法。
经常的写法
我们在设计函数时，错误处理要遵循以下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个小工具：
- check函数，把错误转化为panic
- 函数在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)
}
}
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()函数不够通用，它只接受无入参，无返回的函数。
- 如果这篇文章对你有帮助，不妨关注下我的Github，有文章会收到通知。
- 本文作者：大彬
- 如果喜欢本文，随意转载，但请保留此原文链接：http://lessisbetter.site/2018/10/24/go-handle-error/