不是我吹，你可能连defer都不清楚

在golang中，对于defer，我之前的理解就是和java中的finally代码块一样，没什么难度，但是吧，当我最近看的一些神奇的问题，我就发现原来并非想的那么简单。

先举个栗子

package main

import "fmt"

func main() {
    fmt.Println(DeferFunc1(1))
    fmt.Println(DeferFunc2(1))
    fmt.Println(DeferFunc3(1))
    DeferFunc4()
}

func DeferFunc1(i int) (t int) {
    t = i
    defer func() {
        t += 3
    }()
    return t
}

func DeferFunc2(i int) int {
    t := i
    defer func() {
        t += 3
    }()
    return t
}

func DeferFunc3(i int) (t int) {
    defer func() {
        t += i
    }()
    return 2
}

func DeferFunc4() (t int) {
    defer func(i int) {
        fmt.Println(i)
        fmt.Println(t)
    }(t)
    t = 1
    return 2
}

请问这段代码输出的结果是什么？

答案见文末

如果你看完答对了，那么请直接点击右上角的关闭按钮，如果你答错了，你可以继续往下看了。
下面会一步步介绍，到底为什么结果会是这样

基础知识

函数的返回值初始化

如： func DeferFunc1(i int) (t int) {
其中返回值t int，这个t会在函数起始处被初始化为对应类型的零值并且作用域为整个函数。

defer的执行顺序

虽然这边没有提及，但是还是要说一下，因为很多人学习defer的时候都会用到，就是当多个defer出现的时候，它是一个“栈”的关系，也就是先进后出。一个函数中，写在前面的defer会比写在后面的defer调用的晚。

defer与return谁先谁后

return先，defer后
这个可能会让人怀疑，后面会详细解释。

函数的返回与return

在没有defer的情况下，其实函数的返回就是与return一致的，但是有了defer就不一样了。
函数的返回其实是有两个步骤的，第一个当执行到return语句的时候

func DeferFunc3(i int) (t int) {
    defer func() {
        t += i
    }()
    return 2
}

这个时候会先将返回值t赋值为2，然后执行defer，完成之后才会真正返回外部调用者。

defer调用的三步走

这个就是今天的重头戏了，defer这个语法其实一共有三个步骤。

将defer方法中的参数进行赋值。
将defer压入栈中。
当return或者是panic的时候依次出栈执行。
后面会用实际的例子说明具体执行的情况。

解释

有了上面的所有知识点，其实你就应该能明白上面输出的结果了。如果还不明白就看看下面的分析解释吧。

DeferFunc1

func DeferFunc1(i int) (t int) {
    t = i
    defer func() {
        t += 3
    }()
    return t
}

首先上面是第一个方法

将返回值t赋值为传入的i，此时t为1
执行return语句将t赋值给t（等于啥也没做）
执行defer方法，将t + 3 = 4
函数返回 4
因为t的作用域为整个函数所以修改有效。

DeferFunc2

func DeferFunc2(i int) int {
    t := i
    defer func() {
        t += 3
    }()
    return t
}

第二个方法

创建变量t并赋值为1
执行return语句，注意这里是将t赋值给返回值，此时返回值为1（这个返回值并不是t）
执行defer方法，将t + 3 = 4
函数返回返回值1

可能这里就有点难理解了，修改一下代码你就明白了

func DeferFunc2(i int) (result int) {
    t := i
    defer func() {
        t += 3
    }()
    return t
}

上面的代码return的时候相当于将t赋值给了result，当defer修改了t的值之后，对result是不会造成影响的。

DeferFunc3

func DeferFunc3(i int) (t int) {
    defer func() {
        t += i
    }()
    return 2
}

首先执行return将返回值t赋值为2
执行defer方法将t + 1
最后返回 3

DeferFunc4

func DeferFunc4() (t int) {
    defer func(i int) {
        fmt.Println(i)
        fmt.Println(t)
    }(t)
    t = 1
    return 2
}

这个分析的步骤要详细一些

初始化返回值t为零值 0
首先执行defer的第一步，赋值defer中的func入参t为0
执行defer的第二步，将defer压栈
将t赋值为1
执行return语句，将返回值t赋值为2
执行defer的第三步，出栈并执行
因为在入栈时defer执行的func的入参已经赋值了，此时它作为的是一个形式参数，所以打印为0；相对应的因为最后已经将t的值修改为2，所以再打印一个2

源码一瞥

那么 defer 在底层究竟是如何实现的呢？
通过生成汇编代码我们可以看到下面这样的方法：
CALL runtime.deferproc(SB)
CALL runtime.deferreturn(SB)
实际上来说当我们使用defer的使用就会调用runtime.deferproc，那么这个时候，就会将所有的参数赋值好，所有就像我们上面例子中看到的一样，在调用defer的时候参数会先计算好保存起来，然后挂载到G._defer中，最后deferreturn的时候进行执行相关的defer中的方法

func deferproc(siz int32, fn *funcval) { // arguments of fn follow fn
     sp := getcallersp(unsafe.Pointer(&siz))
     argp := uintptr(unsafe.Pointer(&fn)) + unsafe.Sizeof(fn)
     callerpc := getcallerpc(unsafe.Pointer(&siz))
     systemstack(func() {
            d := newdefer(siz)
})
d.fn = fn
d.pc = callerpc
d.sp = sp
memmove(add(unsafe.Pointer(d), unsafe.Sizeof(*d)),
       unsafe.Pointer(argp), uintptr(siz))
     // deferproc returns 0 normally.
     // a deferred func that stops a panic makes the deferproc return 1.
     // the code the compiler generates always checks the return value and jumps to the
     // end of the function if deferproc returns != 0.
     return0()
}