Go error collection | when a function uses a return value with a parameter name

Hello everyone , I am a Go School fisherman . Today, I'd like to talk to you about what you need to pay attention to when using named parameters of function return values . Original address ：https://mp.weixin.qq.com/s/v6WP1LJGEDt23_lmyLXK1w**01 Introduction to the named return value ** stay Go When defining a method or function in a language , We can not only give functions （ Or method ） The return value of specifies the return type , You can also specify the name of the return parameter . The following function specifies the name of the return value ：```gofunc f(a int) (b int) { b = a return}``` In this way of use , Return value parameter （ Here is b） First, it will be initialized to the zero value of the return type （ here int The zero value of is 0）. secondly , stay return You can add no parameters to the statement , By default, the variable with the same name will be b The value of the return .**02 When to use a return value with a parameter name ** that , In what scenario is the return value with parameter name recommended ？ Let's start with an interface example ：```gotype locator interface { getCoordinates(address string) (float32, float32, error)}``` This interface contains a function to obtain the longitude and latitude coordinates according to the address . There are two in the return value float32 Type value , Longitude and latitude, respectively . Through the signature of the interface, you can know which parameter in the return value is longitude , Which parameter is latitude ？ In general , The first parameter will be latitude , The second parameter would be longitude , But in the end, we need to confirm through specific implementation functions .​ If you add the parameter name to the return value of the method , Then the meaning of each return value can be easily confirmed through the signature of the function . as follows ：```gotype locator interface { getCoordinates(address string) (lat, lng float32, error)}``` that , Do you also need to specify the parameter name in the return value in the specific method that implements the interface ？```gofunc (l loc) getCoordinates(address string) (lat, lng float32, error) { // ...}``` In this example , Because there are two return value types that are the same , So you can improve the readability of the code by specifying the parameter name for the return value , It's easy for code readers to know which return value is longitude , Which return value is the dimension .​ But in some implementation scenarios , You do not need to specify a parameter name for the return value , Nor does it affect readability . For example, our following code , Is a function that stores a customer in a database ：```gofunc StoreCustomer(customer Customer) (err error) { // ...}``` that , There is no point in specifying a parameter name for the return value . Because by error We know that the return value must be a wrong type . therefore , In this case , The return value specifying the parameter name does not improve readability , Try not to specify the parameter value name . Because when the parameter name is specified , This parameter will be initialized to the zero value of the corresponding type , Side effects may occur if you are not careful .​**03 The trap of the named parameter in the return value ** In the example above, you can see , In some scenarios , Specifying a parameter name for the return value improves readability . But at the same time , The parameter value of the return value will be initialized to the zero value of the corresponding type at the beginning of the function . If it is not handled properly in the business logic , It will cause errors . Let's take a look at the following example ：```gofunc (l locator) getCoordinates(ctx context.Context, address string) ( lat, lng float32, err error) { isValid := l.validateAddress(address) if !isValid { return 0, 0, errors.New("invalid address") } if ctx.Err() != nil { return 0, 0, err } // Get and return coordinates}``` In this implementation , First it will pass validateAddress Check the validity of the address . And then it will pass Context Check whether the upper caller is canceled due to timeout . Attention here , If ctx.Err() It's not equal to nil, So back to err When , because err Not assigned , At the same time, because the parameter name is specified in the return value, it is initialized to the corresponding zero value nil, Actually returned err still nil, Does not meet expectations to return a specific error . The solution should be as follows ：```goif err := ctx.Err(); err != nil { return 0, 0, err}```**04 summary ** When specifying a specific parameter name for the return value of a function , Readability can be improved in some scenarios , But at the same time, because the parameter of the return value will be initialized to the zero value of the corresponding type first when the function is called , In concrete logical processing , If you are not careful, you will fall into a trap .​