Why Does `defer` Affect Named Return Values Differently Than Input Parameters in Go?

Understanding the Effects of Defer on Variable Declarations in Go

In Go, the use of the defer keyword allows functions to have code executed at the time of their return, even if panics occur. However, when it comes to variables declared in different ways within a function, the results can vary, leading to confusion.

The Mystery of the Vanishing Increment

Consider the following code snippet:

func c(i int) int {
    defer func() { i++ }()
    return i
}

func main() {
    fmt.Println(c(0)) // Prints 0
}

In this example, we call the c function and pass it the value 0. However, when we print the result, we get 0 rather than the expected 1. This is because i is declared as an input parameter to the function. Once the return statement is executed, the defer function is called, but the increment has no effect on the return value.

The Magic of Named Results

In contrast to the previous example, let's consider the following code:

func c1() (i int) {
    defer func() { i++ }()
    return i
}

func main() {
    fmt.Println(c1()) // Prints 1
}

Here, i is declared as the result parameter for the c1 function. When the return statement is executed, the value of i is set to the return value. However, the defer function is still allowed to modify the value of i before it is returned. This results in the output being 1.

Explicit Returns and Deferred Modifications

To further illustrate this behavior, let's add another example:

func c2() (i int) {
    defer func() { i++ }()
    return 2
}

func main() {
    fmt.Println(c2()) // Prints 3
}

In this example, the return statement explicitly sets i to 2 before the defer function is called. As a result, the defer function increments the value of i, and the return value becomes 3.

The Power of Named Result Parameters

The key takeaway from these examples is the distinction between input parameters and named result parameters. Input parameters are passed into a function, while named result parameters are variables that hold the function's return values. Defer functions can modify named result parameters after the return statement has been executed, but they cannot affect input parameters.

The above is the detailed content of Why Does `defer` Affect Named Return Values Differently Than Input Parameters in Go?. For more information, please follow other related articles on the PHP Chinese website!