知识点1：defer的执行顺序

多个defer出现的时候，它是一个“栈”的关系，也就是先进后出。一个函数中，写在前面的defer会比写在后面的defer调用的晚。

示例代码

1. package       main

2. import “fmt”

1. func main()       {

2. defer       func1()

3. defer       func2()

4. defer       func3()

1. }

1. func func1()       {

2. fmt.Println(“A”)

1. }

1. func func2()       {

2. fmt.Println(“B”)

1. }

1. func func3()       {

2. fmt.Println(“C”)

1. }

输出结果：

1. C

2. B

3. A

知识点2:  defer与return谁先谁后

示例代码

1. package       main

2. import “fmt”

1. func deferFunc() int {

2. fmt.Println(“defer func called”)

1. return 0

1. }

1. func returnFunc() int {

2. fmt.Println(“return func called”)

1. return 0

1. }

1. func returnAndDefer() int {

2. defer       deferFunc()

1. return       returnFunc()

1. }

1. func main()       {

2. returnAndDefer()

1. }

执行结果为：

1. return       func called

1. defer func called

结论为：return之后的语句先执行，defer后的语句后执行

知识点3：函数的返回值初始化

该知识点不属于defer本身，但是调用的场景却与defer有联系，所以也算是defer必备了解的知识点之一。

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

示例代码

1. package       main

2. import “fmt”

1. func DeferFunc1(i int) (t int) {

2. fmt.Println(“t = “,       t)

1. return 2

1. }

1. func main()       {

1. DeferFunc11(10)

1. }

结果

1. t =  0

证明，只要声明函数的返回值变量名称，就会在函数初始化时候为之赋值为0，而且在函数体作用域可见。

知识点4:  有名函数返回值遇见defer情况

 在没有defer的情况下，其实函数的返回就是与return一致的，但是有了defer就不一样了。

 我们通过知识点2得知，先return，再defer，所以在执行完return之后，还要再执行defer里的语句，依然可以修改本应该返回的结果。

1. package       main

2. import “fmt”

1. func returnButDefer() (t int) {  //t初始化0， 并且作用域为该函数全域

2. defer       func() {

3. t       = t * 10

1. }()

1. return 1

1. }

1. func main()       {

2. fmt.Println(returnButDefer())

1. }

该returnButDefer()本应的返回值是1，但是在return之后，又被defer的匿名func函数执行，所以t=t*10被执行，最后returnButDefer()返回给上层main()的结果为10

1. $ go run test.go

1. 10

知识点5:  defer遇见panic

 我们知道，能够触发defer的是遇见return(或函数体到末尾)和遇见panic。

 根据知识点2，我们知道，defer遇见return情况如下： 

 那么，遇到panic时，遍历本协程的defer链表，并执行defer。在执行defer过程中:遇到recover则停止panic，返回recover处继续往下执行。如果没有遇到recover，遍历完本协程的defer链表后，向stderr抛出panic信息。

A.  defer遇见panic，但是并不捕获异常的情况

test10.go

1. package       main

2. import (

1. “fmt”

1. )

1. func main()       {

2. defer_call()

3. fmt.Println(“main 正常结束”)

1. }

1. func defer_call() {

2. defer       func() { fmt.Println(“defer: panic 之前1”) }()

3. defer       func() { fmt.Println(“defer: panic 之前2”) }()

4. panic(“异常内容”)  //触发defer出栈

5. defer       func() { fmt.Println(“defer: panic 之后，永远执行不到”) }()

1. }

结果

1. defer: panic 之前2

2. defer: panic 之前1

3. panic: 异常内容

1. //… 异常堆栈信息

B.  defer遇见panic，并捕获异常

1. package       main

2. import (

1. “fmt”

1. )

1. func main()       {

2. defer_call()

3. fmt.Println(“main 正常结束”)

1. }

1. func defer_call() {

2. defer       func() {

3. fmt.Println(“defer: panic 之前1, 捕获异常”)

1. if err := recover(); err != nil {

1. fmt.Println(err)

1. }

2. }()

1. defer func()       { fmt.Println(“defer: panic 之前2, 不捕获”)       }()

2. panic(“异常内容”)  //触发defer出栈

3. defer       func() { fmt.Println(“defer: panic 之后, 永远执行不到”) }()

1. }

结果

1. defer: panic 之前2, 不捕获

2. defer: panic 之前1, 捕获异常

1. 异常内容

1. main 正常结束

defer 最大的功能是 panic 后依然有效 所以defer可以保证你的一些资源一定会被关闭，从而避免一些异常出现的问题。

知识点6:  defer中包含panic

编译执行下面代码会出现什么?

test16.go

1. package       main

2. import (

1. “fmt”

1. )

1. func main()  {

2. defer       func() {

1. if err := recover(); err != nil{

1. fmt.Println(err)

1. }else {

1. fmt.Println(“fatal”)

1. }

2. }()

1. defer func()       {

2. panic(“defer panic”)

1. }()

1. panic(“panic”)

1. }

结果

1. defer panic

分析

panic仅有最后一个可以被revover捕获。

触发panic(“panic”)后defer顺序出栈执行，第一个被执行的defer中  会有panic(“defer panic”)异常语句，这个异常将会覆盖掉main中的异常panic(“panic”)，最后这个异常被第二个执行的defer捕获到。

知识点7:  defer下的函数参数包含子函数

1. package       main

2. import “fmt”

1. func function(index int, value int) int {

2. fmt.Println(index)

1. return       index

1. }

1. func main()       {

2. defer       function(1, function(3, 0))

3. defer       function(2, function(4, 0))

1. }

 这里，有4个函数，他们的index序号分别为1，2，3，4。

那么这4个函数的先后执行顺序是什么呢？这里面有两个defer，  所以defer一共会压栈两次，先进栈1，后进栈2。  那么在压栈function1的时候，需要连同函数地址、函数形参一同进栈，那么为了得到function1的第二个参数的结果，所以就需要先执行function3将第二个参数算出，那么function3就被第一个执行。同理压栈function2，就需要执行function4算出function2第二个参数的值。然后函数结束，先出栈fuction2、再出栈function1.

 所以顺序如下：

• defer压栈function1，压栈函数地址、形参1、形参2(调用function3)       —> 打印3

• defer压栈function2，压栈函数地址、形参1、形参2(调用function4)       —> 打印4

• defer出栈function2,       调用function2 —> 打印2

• defer出栈function1,       调用function1—> 打印1

1. 3

2. 4

3. 2

4. 1

练习：defer面试真题

了解以上6个defer的知识点，我们来验证一下网上的真题吧。

下面代码输出什么？

test11.go

1. package       main

2. import “fmt”

1. func DeferFunc1(i int) (t int) {

2. t       = i

3. defer       func() {

4. t       += 3

1. }()

1. return t

1. }

1. func DeferFunc2(i int) int {

2. t       := i

3. defer       func() {

4. t       += 3

1. }()

1. return t

1. }

1. func DeferFunc3(i int) (t int) {

2. defer       func() {

3. t       += i

1. }()

1. return 2

1. }

1. func DeferFunc4() (t int) {

2. defer       func(i int) {

3. fmt.Println(i)

4. fmt.Println(t)

1. }(t)

1. t = 1

1. return 2

1. }

1. func main()       {

2. fmt.Println(DeferFunc1(1))

3. fmt.Println(DeferFunc2(1))

4. fmt.Println(DeferFunc3(1))

1. DeferFunc4()

1. }

练习题分析

DeferFunc1

1. func DeferFunc1(i int) (t int) {

2. t       = i

3. defer       func() {

4. t       += 3

1. }()

1. return t

1. }

1. 将返回值t赋值为传入的i，此时t为1

2. 执行return语句将t赋值给t（等于啥也没做）

3. 执行defer方法，将t + 3       = 4

4. 函数返回 4       因为t的作用域为整个函数所以修改有效。

DeferFunc2

1. func DeferFunc2(i int) int {

2. t       := i

3. defer       func() {

4. t       += 3

1. }()

1. return t

1. }

1. 创建变量t并赋值为1

2. 执行return语句，注意这里是将t赋值给返回值，此时返回值为1（这个返回值并不是t）

3. 执行defer方法，将t + 3       = 4

4. 函数返回返回值1

也可以按照如下代码理解

1. func DeferFunc2(i int) (result int) {

2. t       := i

3. defer       func() {

4. t       += 3

1. }()

1. return t

1. }

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

DeferFunc3

1. func DeferFunc3(i int) (t int) {

2. defer       func() {

3. t       += i

1. }()

1. return 2

1. }

1. 首先执行return将返回值t赋值为2

2. 执行defer方法将t + 1

3. 最后返回 3

DeferFunc4

1. func DeferFunc4() (t int) {

2. defer       func(i int) {

3. fmt.Println(i)

4. fmt.Println(t)

1. }(t)

1. t = 1

1. return 2

1. }

1. 初始化返回值t为零值 0

2. 首先执行defer的第一步，赋值defer中的func入参t为0

3. 执行defer的第二步，将defer压栈

4. 将t赋值为1

5. 执行return语句，将返回值t赋值为2

6. 执行defer的第三步，出栈并执行       因为在入栈时defer执行的func的入参已经赋值了，此时它作为的是一个形式参数，所以打印为0；相对应的因为最后已经将t的值修改为2，所以再打印一个2

结果

1. 4

2. 1

3. 3

4. 0

5. 2