今天看了一篇 文章，确实发现自己对 defer 的掌握还不够，文章出了这样一道题。问，以下三个函数，运行后返回是多少，为什么？
func increaseA() int {
var i int
defer func() {
i++
}()
return i
}
func increaseB() (r int) {
defer func() {
r++
}()
return r
}
func increaseC() (r int) {
defer func(r int) {
r++
}(r)
return r
}
这个题 increaseA() 返回 0，而 increaseB() 返回 1，increaseC() 返回 0。
defer 的作用
defer 是 Go 语言提供的一种用于注册延迟调用的机制，每一次 defer 都会把函数压入栈中，当前函数返回前再把延迟函数取出并执行。
defer 定义的函数会先进入一个栈，函数 return 前，会按先进后出（FILO）的顺序执行。也就是说最先被定义的 defer 语句最后执行。
踩坑点
但注意，这远远没概括完 defer 的所有特性。了解 defer 还要牢记以下几个特点。
使用 defer 最容易踩坑的地方是 函数返回参数上指定了参数名 时，返回结果有可能被修改。
defer 语句定义时，对 外部变量的引用 是有两种方式的，分别是作为 函数参数 和作为 闭包引用。
- 作为 函数参数，则在 defer 定义时 就把值传递给 defer，并被 缓存 起来；
- 作为 闭包引用 的话，则会在 defer 函数真正调用时根据整个上下文确定当前的值。
规则一
实参在 defer 函数定义时就取值并缓存起来了。
如：
func trace(str string) string {
fmt.Println("entering " + str)
return str
}
func leave(str string) {
fmt.Println("leaving " + str)
}
func point() {
defer leave(trace("point"))
fmt.Println("in point")
}
func main() {
point()
}
输出
entering point
in point
leaving point
即，在 defer leave(trace("point")) 的流程中，会先执行 trace("point")，然后执行 函数其他语句，最后再来执行 leave(xxx) 函数。
规则二
要完全理解第二条规则，需要了解 return 与 defer 是怎么运行的。
函数内的 return xxx 并不是一个原子执行的返回：即不是先执行 return xxx 再执行 defer，也不是先执行 defer 再执行 return xxx。而是将 return xxx 拆分开来，经过编译后执行过程如下：
1. 返回变量 = xxx
2. 调用 defer 函数（有可能更新返回变量的值）
3. return 返回变量
这里 返回变量 有点特殊，如果在函数签名中定义了返回变量，那么就是它；而如果没有定义，那么返回变量会是一个匿名的变量。defer 函数能够更改函数返回值的情况，都是在函数签名中定义了返回变量的情景。
比如，在以下定义了函数返回变量的案例中，按上述方法拆解一下下面三个函数：
1.
func f1() (r int) {
defer func() {
r++
}()
return 0
}
2.
func f2() (r int) {
t := 5
defer func() {
t = t + 5
}()
return t
}
3.
func f3() (r int) {
defer func(r int) { // 作为函数参数传入 defer 函数
r = r + 5
}(r)
return 1
}
则，第一题中在执行 return 0 时，分成以下三步：
r = 0 // 1. 赋值
func() { // 2. 运行 defer 函数 r++，r = 1
r++
}()
return r // 3. return，即返回结果为 1
第二题中的执行 return t 时，分成一下三步：
r = t (= 5) // 1. 赋值，r 取值 5
func() { // 2. 执行 defer 函数，执行后 t = 10，但 r = 5
t = t + 5
}()
return r // 3. return r，即返回 5
第三题中执行 return 1 时，分为以下三步：
r = 1 // 1. 赋值， r 取值 1
func(r int) { // 2. 执行 defer 函数，但作为函数参数传入
r = r + 5 // 执行后 r = 6 ，但这是局部变量，函数外仍是 1
}(r)
return r // 3. return r， 即返回 1
回到最初的三道题
将解释以注释的方式写在代码中：
func increaseA() int {
var i int
defer func() {
i++
}()
return i // 1. annoy = i (= 0); 2. 执行 defer 函数后 i = 1, 但 annoy = 0; 3. return annoy, 即 0
}
func increaseB() (r int) {
defer func() {
r++
}()
return r // 1. r = r (= 0); 2. 执行 defer 后 r = 1; 3. return r, 即返回 1
}
func increaseC() (r int) {
defer func(r int) {
r++
}(r)
return r // 1. r = 0; 2. 执行 defer r++, 但函数外 r = 0; 3. return r, 即返回 0
}
总结
关于 defer 函数牢记两条规则，并附加一个通用规则
- defer 函数的 参数（实参），在 defer 定义时 就把值传递给 defer，并被 缓存 起来；
- 作为 闭包引用 的话，则会在 defer 函数真正调用时根据整个上下文确定当前的值。这时要牢记“三步走”拆解上下文
- 同时记得，传入函数的参数都是局部变量了（除非匿名函数或引用传入）
网友评论