Error handling trap of golang function

There are four pitfalls when handling function errors in Go: 1) using an empty interface to return an error, 2) delayed evaluation leading to loss of context, 3) accepting errors by value by default, and 4) incorrect alignment. Understanding these pitfalls helps you write robust, clear Go code that handles errors.

Error handling traps of functions in Go

In Go, handling errors is very important, and function error handling provides many The trap may surprise you. Therefore, it is crucial to have a deep understanding of the nuances of error handling.

1. Function type: empty interface

Go functions often return empty interface interface{} of type error. This means it can return nil or have an error value of any type. However, this can lead to confusion because you can't differentiate between nil and actual errors.

Practical example:

func Example(input int) (interface{}, error) {
    if input < 0 {
        return nil, errors.New("input must be non-negative")
    }
    return input * 2, nil
}

It is better to return a clear error type instead of using an empty interface.

2. Delayed evaluation

The error return in Go will delay evaluation. This means that the function body has completed execution before error is accessed. This can cause problems because by the time you access error , the context may have been lost.

Practical example:

func Example(input int) error {
    var err error
    if input < 0 {
        err = errors.New("input must be non-negative")
    }

    if err != nil { 
        return err 
    }

    return nil 
}

In this case, if input is less than 0, Example will return a nil Error because the return statement is executed before err is accessed.

3. Value reception

By default, the error parameter will be received by value. This means that any error value assigned to it will create a copy of error. This can be expensive, especially when dealing with a large number of errors.

Practical example:

func Example(input int) error {
    err := errors.New("input must be non-negative") // 创建一个 error 副本
    if input < 0 {
        return err 
    }
    
    return nil 
}

Using pointers to receive errors can avoid this situation:

func Example(input int) error {
    var err *error // 使用指针接收 error

    if input < 0 {
        err = new(error)
        *err = errors.New("input must be non-negative")
    }

    return *err 
}

4. Error alignment

When When a function is declared with multiple return values, the error should always be the last one returned. The Go compiler aligns errors, and if this convention is not followed, unexpected results may occur.

Practical example:

func Example(input int) (bool, error) {
    if input < 0 {
        return false, errors.New("input must be non-negative")
    }
    return true, nil 
}

If the error is not the last return value, additional code processing is required to ensure alignment.

By understanding these pitfalls, you can write more robust and clear Go code that handles errors.

The above is the detailed content of Error handling trap of golang function. For more information, please follow other related articles on the PHP Chinese website!