Golang中defer和return的执行顺序 + 相关测试题（面试常考）

参考文章：

• 【Golang】defer陷阱和执行原理
  
• GO语言defer和return 的执行顺序
  
• 深入理解Golang defer机制，直通面试
  

面试富途的时候，遇到了1.2的这个进阶问题，没回答出来。这种题简直是 $噩梦$，很久不关注基本上就忘记了…

---

一、关于 go defer、return的执行顺序的 结论

go defer、return的执行顺序：

defer函数恰在return的两个操作之间执行。因为 return包含两个操作：先将结果写入返回值中，然后携带当前返回值退出。

因此，defer、return的最终执行顺序为：
1. return最先执行，return负责将结果写入返回值中
2. 接着defer开始执行一些收尾工作
3. 最后函数携带当前返回值退出

如果所在函数为有名返回值函数，return第一步先把返回值放到有名返回值变量中，如果恰好defer函数中修改了该返回值，那么最终返回值是更新后的。
但是如果所在函数为无名返回值函数，那么return第一步先把返回值放到一个临时变量中，defer函数无法获取到这个临时变量地址，所以无论defer函数做任何操作，都不会对最终返回值造成任何变动。

**

二、defer相关测试题

2.1 关于 defer 函数后的 匿名/有名 返回值对输出结果的影响：

package main

import (
    "fmt"
)

func f1() int {
    var i int
    defer func(){
        i++
    }()
    return i    
}

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

func main() {
    fmt.Println(f1())
    fmt.Println(f2())
}

上面的程序输出结果是啥呢？答案是：0 1

我们知道Golang中的函数返回值有匿名和有名两种。

• 对于匿名的可以理解成执行return 语句时，分成两步，第一步需要设置一个临时变量s用来接收返回值，第二步将临时变量s返回。
• 对于有名的可以理解成执行return的时候，直接将变量返回。

而我们知道，所有的defer都将在真正的 return 变量之前运行，所以对于上面两种情况，defer对于返回值的影响也有两种：

• 对于匿名的：第一步设置临时变量保存返回值；第二步按照defer的执行步骤执行defer语句，如果其中有对变量的修改，将不会影响s变量的值。
• 对于有名的：第一步先执行defer，对变量进行修改；第二步，返回被修改的返回值。

所以，理解了上面的步骤的之后，我们就可以理解 f1() 和 f2() 这两个的函数了，在执行 return 时：

• f1函数先通过临时变量s保存i的值，此时i为0，所以s=0，然后执行defer，修改i的值，i变为1，最后返回s的值，因为s=0，所以返回值是0；
• 而f2是有名函数，所以在执行 return 时，执行 i++ 后 i 的值为1，然后真正的返回 i 值，所以返回的是 1。

---

2.2 关于defer的进阶测试题

再来看一段示例代码：

可以先尝试想想以下的几个函数分别会输出什么内容？

func test1() (x int) {
	defer fmt.Printf("in defer: x = %d\n", x)
	x = 7
	return 9
}
 
func test2() (x int) {
	x = 7
	defer fmt.Printf("in defer: x = %d\n", x)
	return 9
}
 
func test3() (x int) {
	defer func() {
		fmt.Printf("in defer: x = %d\n", x)
	}()
 
	x = 7
	return 9
}
 
func test4() (x int) {
	defer func(n int) {
		fmt.Printf("in defer x as parameter: x = %d\n", n)
		fmt.Printf("in defer x after return: x = %d\n", x)
	}(x)
 
	x = 7
	return 9
}
 
func main() {
	fmt.Println("test1")
	fmt.Printf("in main: x = %d\n", test1())
	fmt.Println("test2")
	fmt.Printf("in main: x = %d\n", test2())
	fmt.Println("test3")
	fmt.Printf("in main: x = %d\n", test3())
	fmt.Println("test4")
	fmt.Printf("in main: x = %d\n", test4())
}

你已经计算出结果了吗？看看和运行结果是不是一样的，如果不一样继续阅读本文吧：

test1
in defer: x = 0
in main: x = 9
test2
in defer: x = 7
in main: x = 9
test3
in defer: x = 9
in main: x = 9
test4
in defer x as parameter: x = 0
in defer x after return: x = 9
in main: x = 9

---

进阶测试题 解析

在看解析之前，先理解下 return 语句的执行顺序：
return语句本身并不是一条原子指令，它会先给返回值赋值，然后再是真正的返回结果到函数外部，如下：

func f() (r int) {
 return 1
}

//执行过程：
r:=1 //赋值
ret  //执行返回

而在含defer表达式时，函数返回的过程是这样的：
先给返回值赋值，然后调用defer表达式，最后再是返回结果。

这4个测试函数中，都是return 9并且没有对返回值进行修改，所以主函数main()中的输出都是：in main: x = 9，我相信这个大家应该是没有疑问的。接下来看每个测试函数defer的打印。

test1：defer执行时，对Printf的入参x进行计算，它的值是0，并且传递给函数，return 9后执行Printf，所以结果是in defer: x = 0。

func test1() (x int) {
	// defer后接【表达式】：
	// 起初x作为入参值为0，结果一直保留在栈中，最后直接打印输出，不受后续影响
	defer fmt.Printf("in defer: x = %d\n", x)
	x = 7
	// 返回值为 9
	return 9
}

test2：与test1类似，不同的是，defer执行是在x=7之后，所以x的值是7，并且传递给Printf，所以结果是：in defer: x = 7。

func test2() (x int) {
	x = 7
	// defer后接【表达式】：
	// 起初x作为入参值为7，结果一直保留在栈中，最后直接打印输出，不受后续影响
	defer fmt.Printf("in defer: x = %d\n", x)
	// 返回值为 9
	return 9
}

test3：defer后跟的是一个匿名函数，匿名函数能访问外部函数的变量，这里访问的是test3的x，defer执行时，匿名函数没有入参，所以把func()()压入到栈，return语句之后，执行func()()，此时匿名函数获得x的值是9，所以结果是in defer: x = 9。

func test3() (x int) {
	// defer后接【匿名函数】：
	defer func() {
		// 匿名函数能访问外部函数的变量，受后续return x的结果影响
		// 也就是说【defer匿名函数内要访问的变量 x】最终会被【defer匿名函数外最终要 return 返回出去的变量 x】所影响
		fmt.Printf("in defer: x = %d\n", x)
	}()
 
	x = 7
	// 返回值为 9
	return 9
}

test4：与test3的不同是，匿名函数有一个入参n，我们把x作为入参打印，还有就是匿名函数中的x能访问外部函数的变量x。defer执行时，x=0，所以入栈的函数是func(int)(0)，return语句之后执行func(int)(0)，即n=0，x在匿名函数内没有定义，依然访问test4中的x，此时x=9，所以结果为：in defer x as parameter: x = 0, in defer x after return: x = 9。

func test4() (x int) {
	// defer后接【匿名函数】：
	defer func(n int) {
		// 针对【defer匿名函数内要访问的变量 n】，其值取决于在一开始遇到 defer 时入参 n 的值，
		// 也就是最开始还没被改变时的变量 x 的值，将其赋值给入参 n，起初是0
		// 这个变量 n 的值是独立的，不会受后续 return x 结果的影响。
		fmt.Printf("in defer x as parameter: x = %d\n", n)
		fmt.Printf("in defer x after return: x = %d\n", x)
	}(x)
 
	x = 7
	return 9
}

---

小结：

• 首先要明确 defer 后紧接的代码可以有两种写法：
  • defer + 表达式，例如：defer fmt.Printf("in defer: x = %d\n", x)
    此时就会直接保留当前变量 x 已有的值到栈中，一直到最后直接打印输出，不再受后续 return x 结果的影响。$例如test1和test2中的变量x。$
  • defer + 匿名函数（无入参/有入参），例如：test3中的 defer func() {fmt.Printf("in defer: x = %d\n", x)}()或 test4中 defer func(n int) {fmt.Printf("in defer x as parameter: x = %d\n", n) fmt.Printf("in defer x after return: x = %d\n", x)}(x)
    此时需要区分打印输出的变量到底是【defer匿名函数内要访问的变量 n】，还是【defer匿名函数内要访问的变量 x】。
    • 针对【defer匿名函数内要访问的变量 n】，其值取决于在一开始遇到 defer 时入参 n 的值（也就是最开始还没被改变时的变量 x 的值，起初是0）。这个变量 n 的值是独立的，不会受后续 return x 结果的影响。$例如test4中的变量n。$
    • 针对【defer匿名函数内要访问的变量 x】，由于匿名函数能访问外部函数的变量，也就是说【defer匿名函数内要访问的变量 x】最终会被【defer匿名函数外最终要 return 返回出去的变量 x】所影响。$例如test3和test4中的变量x。$