How Do Named and Normal Returns in Go Differ When a Function Panics?

Why a Normal Return Hides a Panic that a Named Return Provides to the Caller

In Go, both normal and named return statements are used to return values from a function. However, there is a subtle difference in their behavior when a function panics.

In a normal return, the return values are initialized to their zero values when the function is called. If the function panics before reaching a return statement, the return values remain at their zero values. For example, if a function returns an error value, a normal return will always return nil if the function panics.

In contrast, named returns allow the return values to be modified by deferred functions or by the function itself before the function returns to its caller. If a function with named returns panics, deferred functions can modify the return values before the function returns to its caller.

This difference can be illustrated with the following example:

package main

import (
    "fmt"
    "log"
)

func catch(err *error) {
    if r := recover(); r != nil {
        *err = fmt.Errorf("recovered panic: %v", r)
    }
}

func panicIf42(n int) {
    if n == 42 {
        panic("42!")
    }
}

func NormalReturns(n int) error {
    var err error
    defer catch(&err)
    panicIf42(n)
    return err
}

func NamedReturns(n int) (err error) {
    defer catch(&err)
    panicIf42(n)
    return
}

func main() {
    err := NamedReturns(42)
    log.Printf("NamedReturns error: %v", err)
    err = NormalReturns(42)
    log.Printf("NormalReturns error: %v", err)
}

The output of this program is:

2009/11/10 23:00:00 NamedReturns error: recovered panic: 42!
2009/11/10 23:00:00 NormalReturns error: <nil>

As you can see, the named return returns a non-nil error, while the normal return returns nil. This is because the NamedReturns function's deferred catch function modifies the err return value before the function returns to its caller.

This behavior can be useful for handling errors in a consistent way throughout a program. By using named returns, you can ensure that all functions return a non-nil error if they panic, even if the panic occurs before the function reaches a return statement.

The above is the detailed content of How Do Named and Normal Returns in Go Differ When a Function Panics?. For more information, please follow other related articles on the PHP Chinese website!