Golang中重复错误处理的优化方法

开扎古的杂鱼

Golang 错误处理最让人头疼的问题就是代码里充斥着「if err != nil」，它们破坏了代码的可读性，本文收集了几个例子，让大家明白如何优化此类问题。
让我们看看 Errors are values 中提到的一个 io.Writer 例子：

1. _, err = fd.Write(p0[a:b])
   
2. if err != nil {
   
3. return err
   
4. }
   
5. _, err = fd.Write(p1[c:d])
   
6. if err != nil {
   
7. return err
   
8. }
   
9. _, err = fd.Write(p2[e:f])
   
10. if err != nil {
    
11. return err
    
12. }

复制代码

如上代码乍一看无法直观的看出其本来的意图是什么，改进版：

1. type errWriter struct {
   
2. w io.Writer
   
3. err error
   
4. }
   
5. 
   
6. func (ew *errWriter) write(buf []byte) {
   
7. if ew.err != nil {
   
8. return
   
9. }
   
10. _, ew.err = ew.w.Write(buf)
    
11. }
    
12. 
    
13. ew := &errWriter{w: fd}
    
14. ew.write(p0[a:b])
    
15. ew.write(p1[c:d])
    
16. ew.write(p2[e:f])
    
17. if ew.err != nil {
    
18. return ew.err
    
19. }

复制代码

通过自定义类型 errWriter 来封装 io.Writer，并且封装了 error，新类型有一个 write 方法，不过其方法签名并没有返回 error，而是在方法内部判断一旦有问题就立刻返回，有了这些准备工作，我们就可以把原本穿插在业务逻辑中间的错误判断提出来放到最后来统一调用，从而在视觉上保证让人可以直观的看出代码本来的意图是什么。
让我们再看看 Eliminate error handling by eliminating errors 中提到的另一个 io.Writer 例子：

1. type Header struct {
   
2. Key, Value string
   
3. }
   
4. 
   
5. type Status struct {
   
6. Code int
   
7. Reason string
   
8. }
   
9. 
   
10. func WriteResponse(w io.Writer, st Status, headers []Header, body io.Reader) error {
    
11. _, err := fmt.Fprintf(w, "HTTP/1.1 %d %s\r\n", st.Code, st.Reason)
    
12. if err != nil {
    
13. return err
    
14. }
    
15. 
    
16. for _, h := range headers {
    
17. _, err := fmt.Fprintf(w, "%s: %s\r\n", h.Key, h.Value)
    
18. if err != nil {
    
19. return err
    
20. }
    
21. }
    
22. 
    
23. if _, err := fmt.Fprint(w, "\r\n"); err != nil {
    
24. return err
    
25. }
    
26. 
    
27. _, err = io.Copy(w, body)
    
28. return err
    
29. }

复制代码

第一感觉既然错误是 fmt.Fprint 和 io.Copy 返回的，是不是我们要重新封装一下它们？实际上真正的源头是它们的参数 io.Writer，因为直接调用 io.Writer 的 Writer 方法的话，方法签名中有返回值 error，所以每一步 fmt.Fprint 和 io.Copy 操作都不得不进行重复的错误处理，看上去是坏味道，改进版：

1. type errWriter struct {
   
2. io.Writer
   
3. err error
   
4. }
   
5. 
   
6. func (e *errWriter) Write(buf []byte) (int, error) {
   
7. if e.err != nil {
   
8. return 0, e.err
   
9. }
   
10. 
    
11. var n int
    
12. n, e.err = e.Writer.Write(buf)
    
13. return n, nil
    
14. }
    
15. 
    
16. func WriteResponse(w io.Writer, st Status, headers []Header, body io.Reader) error {
    
17. ew := &errWriter{Writer: w}
    
18. fmt.Fprintf(ew, "HTTP/1.1 %d %s\r\n", st.Code, st.Reason)
    
19. 
    
20. for _, h := range headers {
    
21. fmt.Fprintf(ew, "%s: %s\r\n", h.Key, h.Value)
    
22. }
    
23. 
    
24. fmt.Fprint(ew, "\r\n")
    
25. io.Copy(ew, body)
    
26. 
    
27. return ew.err
    
28. }

复制代码

通过自定义类型 errWriter 来封装 io.Writer，并且封装了 error，同时重写了 Writer 方法，虽然方法签名中仍然有返回值 error，但是我们单独保存了一份 error，并且在方法内部判断一旦有问题就立刻返回，有了这些准备工作，新版的 WriteResponse 不再有重复的错误判断，只需要在最后检查一下 error 即可。
类似的做法在 Golang 标准库中屡见不鲜，让我们继续看看 Eliminate error handling by eliminating errors 中提到的一个关于 bufio.Reader 和 bufio.Scanner 的例子：

1. func CountLines(r io.Reader) (int, error) {
   
2. var (
   
3. br = bufio.NewReader(r)
   
4. lines int
   
5. err error
   
6. )
   
7. 
   
8. for {
   
9. _, err = br.ReadString('\n')
   
10. lines++
    
11. if err != nil {
    
12. break
    
13. }
    
14. }
    
15. 
    
16. if err != io.EOF {
    
17. return 0, err
    
18. }
    
19. 
    
20. return lines, nil
    
21. }

复制代码

我们构造一个 bufio.Reader，然后在一个循环中调用 ReadString 方法，如果读到文件结尾，那么 ReadString 会返回一个错误（io.EOF），为了判断此类情况，我们不得不在每次循环时判断「if err != nil」，看上去这是坏味道，改进版：

1. func CountLines(r io.Reader) (int, error) {
   
2. sc := bufio.NewScanner(r)
   
3. lines := 0
   
4. 
   
5. for sc.Scan() {
   
6. lines++
   
7. }
   
8. 
   
9. return lines, sc.Err()
   
10. }

复制代码

实际上，和 bufio.Reader 相比，bufio.Scanner 是一个更高阶的类型，换句话简单点来说的话，相当于是 bufio.Scanner 抽象了 bufio.Reader，通过把低阶的 bufio.Reader 换成高阶的 bufio.Scanner，循环中不再需要判断「if err != nil」，因为 Scan 方法签名不再返回 error，而是返回 bool，当在循环里读到了文件结尾的时候，循环直接结束，如此一来，我们就可以统一在最后调用 Err 方法来判断成功还是失败，看看 Scanner 的定义：

1. type Scanner struct {
   
2. r   io.Reader // The reader provided by the client.
   
3. split  SplitFunc // The function to split the tokens.
   
4. maxTokenSize int  // Maximum size of a token; modified by tests.
   
5. token  []byte // Last token returned by split.
   
6. buf   []byte // Buffer used as argument to split.
   
7. start  int  // First non-processed byte in buf.
   
8. end   int  // End of data in buf.
   
9. err   error  // Sticky error.
   
10. empties  int  // Count of successive empty tokens.
    
11. scanCalled bool  // Scan has been called; buffer is in use.
    
12. done   bool  // Scan has finished.
    
13. }

复制代码

可见 Scanner 封装了 io.Reader，并且封装了 error，和我们之前讨论的做法一致。有一点说明一下，实际上查看 Scan 源代码的话，你会发现它不是通过 err 来判断是否结束的，而是通过 done 来判断是否结束，这是因为 Scan 只有遇到文件结束的错误才退出，其它错误会继续执行，当然，这只是具体的细节问题，不影响我们的结论。
通过对以上几个例子的分析，我们可以得出优化重复错误处理的大概套路：通过创建新的类型来封装原本干脏活累活的旧类型，同时在新类型中封装 error，新旧类型的方法签名可以保持兼容，也可以不兼容，这个不是关键的，视客观情况而定，至于具体的逻辑实现，先判断有没有 error，如果有就直接退出，如果没有就继续执行，并且在执行过程中保存可能出现的 error 以便后面操作使用，最后通过统一调用新类型的 error 来完成错误处理。提醒一下，此方案的缺点是要到最后才能知道有没有错误，好在如此的控制粒度在多数时候并无大碍。
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对晓枫资讯的支持。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

紫菘丝丝凭

看看，学习学习～～～～

乜幻彤

谢谢分享~~~~~

原野同学

感谢楼主分享。

执节者歌倮

顶顶更健康！！！

123459961

感谢楼主，顶。