How to optimize repeated if err in go language= Nil template code?

Hello everyone , I am a frank.

01

Introduce

Go Language error handling has been a part of the community Go Developer criticism , Which repeats if err != nil Boilerplate code is the most interesting Go Developers can't stand , Seriously reduce the readability of the code .

A very heated topic in this community , The author introduces two optimization methods if err != nil The way of boilerplate code .

02

Encapsulate the error checking function

Error checking function sample code ：

func CheckErrors (err error) {
    if err != nil {
        // do something
    }
}

Copy

Call the error checking function sample code ：

err := SomeMethod()
CheckErrors(err)

Copy

Read the code above , Encapsulate an error checking function , Where errors need to be handled in the code , Call this function directly .

This way, , Although it improves the readability of the code visually , But there are also limitations in scenarios that require special error handling , For example, when you need to use additional information to improve the error , This method is not applicable to such scenarios .

03

Define the error information field in the structure

We can define the error information field in the structure , Bind the method of the structure with the error message .

Sample code ：

type Writer struct {
 err error
 buf []byte
 n   int
 wr  io.Writer
}

func (b *Writer) Flush() error {
 if b.err != nil {
  return b.err
 }
 // ...
 return nil
}

Copy

read Go Standard library bufio Code snippet of , We can find it in Writer Define a in the structure err Field , Encapsulate the error information in the structure .

stay Writer At the beginning of the structure method, judge err Is the field nil, If err The value of the field is not nil, Then return directly err, Thereby reducing if err != nil Repetition of boilerplate code .

04

summary

In this article, we introduce how to optimize Go Repeated in language if err != nil Two ways of boilerplate code , The author recommends using the second method , Because the first way is simple , But it is not suitable for some specific scenes .

By defining the field of error information in the structure , The optimization method that binds the method of the structure with the error information , Compared with the first way, it is more elegant .

Reference material ：

1. https://www.reddit.com/r/golang/comments/6v07ij/copypasting_if_err_nil_return_err_everywhere/
2. https://www.reddit.com/r/golang/comments/649o0c/syncx_go_library_that_extends_standard_sync/
3. https://go.dev/blog/errors-are-values
4. https://pkg.go.dev/golang.org/x/sync/errgroup
5. https://pkg.go.dev/github.com/facebookgo/stackerr#section-readme