在用Golang开发的时候,`defer`这个语法也是必备的知识,但是我们除了知道他是在一个函数退出之前执行,对于`defer`是否还有其他地方需要注意的呢。
本文整理的`defer`的全场景使用情况,部分场景源自网络,加上自己的额外观点和分析,完成了这份`defer`的7个隐性必备知识点。
提纲如下:
* 知识点1: defer的执行顺序
* 知识点2:defer与return谁先谁后
* 知识点3:函数的返回值初始化与defer间接影响
* 知识点4:有名函数返回值遇见defer情况
* 知识点5:defer遇见panic
* 知识点6:defer中包含panic
* 知识点7:defer下的函数参数包含子函数
---
#### 知识点1:defer的执行顺序
多个defer出现的时候,**它是一个“栈”的关系,也就是先进后出**。一个函数中,写在前面的defer会比写在后面的defer调用的晚。
> 示例代码
```go
package main
import "fmt"
func main() {
defer func1()
defer func2()
defer func3()
}
func func1() {
fmt.Println("A")
}
func func2() {
fmt.Println("B")
}
func func3() {
fmt.Println("C")
}
```
![](https://upload-images.jianshu.io/upload_images/11093205-931c1eca3eb850ab.jpeg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
输出结果:
```bash
C
B
A
```
---
#### 知识点2: defer与return谁先谁后
> 示例代码
```go
package main
import "fmt"
func deferFunc() int {
fmt.Println("defer func called")
return 0
}
func returnFunc() int {
fmt.Println("return func called")
return 0
}
func returnAndDefer() int {
defer deferFunc()
return returnFunc()
}
func main() {
returnAndDefer()
}
```
执行结果为:
```bash
return func called
defer func called
```
结论为:**return之后的语句先执行,defer后的语句后执行**
---
#### 知识点3:函数的返回值初始化
该知识点不属于defer本身,但是调用的场景却与defer有联系,所以也算是defer必备了解的知识点之一。
如 : `func DeferFunc1(i int) (t int) {}`
其中返回值`t int`,这个`t`会在函数起始处被初始化为对应类型的零值并且作用域为整个函数。
![](https://upload-images.jianshu.io/upload_images/11093205-508b2677442f4482.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
> 示例代码
```go
package main
import "fmt"
func DeferFunc(i int) (t int) {
fmt.Println("t = ", t)
return 2
}
func main() {
DeferFunc(10)
}
```
结果
```bash
t = 0
```
证明,**只要声明函数的返回值变量名称,就会在函数初始化时候为之赋值为0,而且在函数体作用域可见**。
---
#### 知识点4: 有名函数返回值遇见defer情况
在没有defer的情况下,其实函数的返回就是与return一致的,但是有了defer就不一样了。
我们通过**知识点2**得知,先return,再defer,所以在执行完return之后,还要再执行defer里的语句,依然可以修改本应该返回的结果。
```go
package main
import "fmt"
func returnButDefer() (t int) { //t初始化0, 并且作用域为该函数全域
defer func() {
t = t * 10
}()
return 1
}
func main() {
fmt.Println(returnButDefer())
}
```
该`returnButDefer()`本应的返回值是`1`,但是在return之后,又被defer的匿名func函数执行,所以`t=t*10`被执行,最后`returnButDefer()`返回给上层`main()`的结果为`10`
```bash
$ go run test.go
10
```
---
#### 知识点5: defer遇见panic
我们知道,能够触发defer的是遇见return(或函数体到末尾)和遇见panic。
根据**知识点2**,我们知道,defer遇见return情况如下:
![](https://upload-images.jianshu.io/upload_images/11093205-26ab74a305124af6.jpeg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
那么,遇到panic时,遍历本协程的defer链表,并执行defer。在执行defer过程中:遇到recover则停止panic,返回recover处继续往下执行。如果没有遇到recover,遍历完本协程的defer链表后,向stderr抛出panic信息。
![](https://upload-images.jianshu.io/upload_images/11093205-225f0a7e73bb2749.jpeg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
##### A. defer遇见panic,但是并不捕获异常的情况
> test10.go
```go
package main
import (
"fmt"
)
func main() {
defer_call()
fmt.Println("main 正常结束")
}
func defer_call() {
defer func() { fmt.Println("defer: panic 之前1") }()
defer func() { fmt.Println("defer: panic 之前2") }()
panic("异常内容") //触发defer出栈
defer func() { fmt.Println("defer: panic 之后,永远执行不到") }()
}
```
**结果**
```bash
defer: panic 之前2
defer: panic 之前1
panic: 异常内容
//... 异常堆栈信息
```
##### B. defer遇见panic,并捕获异常
```go
package main
import (
"fmt"
)
func main() {
defer_call()
fmt.Println("main 正常结束")
}
func defer_call() {
defer func() {
fmt.Println("defer: panic 之前1, 捕获异常")
if err := recover(); err != nil {
fmt.Println(err)
}
}()
defer func() { fmt.Println("defer: panic 之前2, 不捕获") }()
panic("异常内容") //触发defer出栈
defer func() { fmt.Println("defer: panic 之后, 永远执行不到") }()
}
```
**结果**
```go
defer: panic 之前2, 不捕获
defer: panic 之前1, 捕获异常
异常内容
main 正常结束
```
**defer 最大的功能是 panic 后依然有效**
所以defer可以保证你的一些资源一定会被关闭,从而避免一些异常出现的问题。
---
#### 知识点6: defer中包含panic
> 编译执行下面代码会出现什么?
> test16.go
```go
package main
import (
"fmt"
)
func main() {
defer func() {
if err := recover(); err != nil{
fmt.Println(err)
}else {
fmt.Println("fatal")
}
}()
defer func() {
panic("defer panic")
}()
panic("panic")
}
```
**结果**
```bash
defer panic
```
**分析**
**panic仅有最后一个可以被revover捕获**。
触发`panic("panic")`后defer顺序出栈执行,第一个被执行的defer中 会有`panic("defer panic")`异常语句,这个异常将会覆盖掉main中的异常`panic("panic")`,最后这个异常被第二个执行的defer捕获到。
---
#### 知识点7: defer下的函数参数包含子函数
```go
package main
import "fmt"
func function(index int, value int) int {
fmt.Println(index)
return index
}
func main() {
defer function(1, function(3, 0))
defer function(2, function(4, 0))
}
```
这里,有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
```bash
3
4
2
1
```
---
#### 练习:defer面试真题
了解以上6个defer的知识点,我们来验证一下网上的真题吧。
下面代码输出什么?
> test11.go
```go
package main
import "fmt"
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 main() {
fmt.Println(DeferFunc1(1))
fmt.Println(DeferFunc2(1))
fmt.Println(DeferFunc3(1))
DeferFunc4()
}
```
---
#### 练习题分析
##### DeferFunc1
```go
func DeferFunc1(i int) (t int) {
t = i
defer func() {
t += 3
}()
return t
}
```
1. 将返回值t赋值为传入的i,此时t为1
2. 执行return语句将t赋值给t(等于啥也没做)
3. 执行defer方法,将t + 3 = 4
4. 函数返回 4
因为t的作用域为整个函数所以修改有效。
##### DeferFunc2
```go
func DeferFunc2(i int) int {
t := i
defer func() {
t += 3
}()
return t
}
```
1. 创建变量t并赋值为1
2. 执行return语句,注意这里是将t赋值给返回值,此时返回值为1(这个返回值并不是t)
3. 执行defer方法,将t + 3 = 4
4. 函数返回返回值1
也可以按照如下代码理解
```go
func DeferFunc2(i int) (result int) {
t := i
defer func() {
t += 3
}()
return t
}
```
上面的代码return的时候相当于将t赋值给了result,当defer修改了t的值之后,对result是不会造成影响的。
##### DeferFunc3
```go
func DeferFunc3(i int) (t int) {
defer func() {
t += i
}()
return 2
}
```
1. 首先执行return将返回值t赋值为2
2. 执行defer方法将t + 1
3. 最后返回 3
##### DeferFunc4
```go
func DeferFunc4() (t int) {
defer func(i int) {
fmt.Println(i)
fmt.Println(t)
}(t)
t = 1
return 2
}
```
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
##### **结果**
```bash
4
1
3
0
2
```
---
---
###关于作者:
mail: [danbing.at@gmail.com](mailto:danbing.at@gmail.com)
github: [https://github.com/aceld](https://github.com/aceld)
原创书籍gitbook: [http://legacy.gitbook.com/@aceld](http://legacy.gitbook.com/@aceld)
## 创作不易, 共同学习进步, 欢迎关注作者, 回复"zinx"有好礼
![作者微信公众号](https://upload-images.jianshu.io/upload_images/11093205-d0aa3a4b0bb76b16.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
---
## 文章推荐
#### 开源软件作品
[(原创开源)Zinx-基于Golang轻量级服务器并发框架-完整版(附教程视频)](https://www.jianshu.com/p/23d07c0a28e5)
[(原创开源)Lars-基于C++负载均衡远程调度系统-完整版](https://www.jianshu.com/p/ca3849716cd7)
#### 精选文章
[典藏版-Golang调度器GMP原理与调度全分析](https://www.jianshu.com/p/fa696563c38a)
[Golang三色标记、混合写屏障GC模式图文全分析](https://www.jianshu.com/p/4c5a303af470)
[最常用的调试 golang 的 bug 以及性能问题的实践方法?](https://www.jianshu.com/p/9c6e4cc94dda)
[Golang中的局部变量“何时栈?何时堆?”](https://www.jianshu.com/p/e42131184ea1)
[使用Golang的interface接口设计原则](https://www.jianshu.com/p/c03d2a807e94)
[流?I/O操作?阻塞?epoll?](https://www.jianshu.com/p/ddb31af0b061)
[深入浅出Golang的协程池设计](https://www.jianshu.com/p/508f5d3b2f59)
[Go语言构建微服务一站式解决方案](https://www.jianshu.com/p/7fe7a8507745)
---
有疑问加站长微信联系(非本文作者)