Go 命名返回值的 defer 陷阱

go func noName() int { var i int defer func() { i++ // 修改的是局部变量 i }() return i }

func withName() (i int) { defer func() { i++ // 直接修改命名返回值 i }() return }

func main() { fmt.Println(noName()) // 0 fmt.Println(withName()) // 1 }

**解释**：
`noName` 函数中，`return i` 先把局部变量 `i` 的值（0）复制给一个匿名返回变量，然后执行 `defer`。此时 `defer` 里 `i++` 只改了局部变量 `i`，对返回值没影响，所以返回 0。
`withName` 函数则有命名返回值 `i`。`return` 先把 `i`（此时值为 0）赋值给**这个命名返回值**，然后执行 `defer`，`defer` 里 `i++` 直接操作的是同一个返回值变量，将其改为 1，最终函数返回 1。

**结论**：如果你在 `defer` 中修改了一个命名返回值，调用者会收到修改后的值。

## 3. 陷阱二：短变量声明引入的“影子变量”

在 `defer` 里不小心用 `:=` 会创建一个**同名的局部变量**，而不是修改命名返回值。

```go
func shadowValue() (result int) {
    defer func() {
        result := 5 // 这是一个全新的变量，遮蔽了外层的 result
        result *= 2
    }()
    return 3
}

func main() {
    fmt.Println(shadowValue()) // 输出 3，不是 10
}

defer 里的 result := 5 声明并初始化了一个仅在闭包内有效的 result，与外层的命名返回值同名但完全独立。外层的 result 始终保持赋值时的 3。想要修改命名返回值必须直接赋值：result = 5。

4. 陷阱三：return 带上表达式的赋值时机

即使有命名返回值，如果在 return 后面写了一个表达式，赋值仍优先，然后 defer 运行，最终返回的是 defer 执行后的结果。

func order() (x int) {
    defer func() {
        x = 20
    }()
    return 10
}

func main() {
    fmt.Println(order()) // 输出 20
}

执行顺序分解：

1. x = 10 (因为 return 10 先把 10 赋给命名返回值 x)
2. 执行 defer：x = 20，把返回值修改为 20
3. 函数返回 x 的当前值 20

看上去 return 10 好像被“覆盖”了，其实只是 defer 后于赋值执行。

5. 陷阱四：defer 参数在声明时求值，闭包引用才“实时”

这个陷阱与命名返回值关系不大，但常跟 defer 混淆使用，一并说明。

func deferParam() (i int) {
    i = 1
    defer func(n int) {
        fmt.Println(n) // 参数在 defer 注册时已经复制
    }(i) // 此时 i = 1，所以 n = 1
    i = 2
    return i
}

func deferClosure() (i int) {
    i = 1
    defer func() {
        fmt.Println(i) // 闭包直接引用变量 i
    }()
    i = 2
    return i
}

func main() {
    deferParam()   // 输出 1
    deferClosure() // 输出 2
}

如果你的 defer 想根据最终返回值做某些事（比如记录日志），应该使用无参闭包，直接读取命名返回值。

6. 真实场景与最佳实践

6.1 利用 defer 修改错误或返回值

命名返回值 + defer 并非全是坑，它也可以写出简洁的错误处理代码：

func readFile(path string) (content string, err error) {
    f, err := os.Open(path)
    if err != nil {
        return "", err
    }
    defer func() {
        if closeErr := f.Close(); closeErr != nil && err == nil {
            err = closeErr // 将关闭文件的错误冒泡出去
        }
    }()
    // ... 读取内容，给 content 赋值
    return
}

6.2 避免陷阱的几条准则

1. 明确意图：只在你确实需要 defer 修改返回值时才使用命名返回值，否则写普通返回值更安全。
2. 不用 := 操作命名返回值：在 defer 里修改命名返回值直接用 =。
3. 返回值命名不宜过多：尽量只对错误、关闭状态这类特殊的返回值使用命名。
4. 用测试覆盖边界：涉及 defer + 命名返回值的函数，必须写清楚单元测试。

7. 快速自测

请说出以下函数的输出，检验你的理解：

func quiz1() (r int) {
    defer func() {
        r = r + 5
    }()
    return 1
}

func quiz2() (r int) {
    defer func(r int) {
        r = r + 5
    }(r)
    return 1
}

func quiz3() (r int) {
    defer func() {
        r++
    }()
    return r
}