1.简介
defer是Go语言中的延迟调用函数，它是在函数真正返回之前立即执行，一般用于资源回收、捕捉异常操作，其实现原理是：
1）在对应语句打上标签，告诉系统，先不要调用、先执行入栈操作，待函数退栈时在一并调用；
2）当defer语句入栈时，会将函数地址、函数实参一同入栈，如果实参是表达式、函数语句，则会优先运行；
3）函数退栈时，无论是正常调用结束还是触发panic，都会调用之前入栈的defer语句，若有多个defer语句时，则按照FILO顺序执行调用；
2.使用
下面介绍defer语句的使用特点。
2.1延迟调用
defer是延迟调用的，是在函数退栈前才被调用的，如：
```go
func main() {
defer fmt.Println("A")
fmt.Println("B")
}```
输出顺序：B A
2.2生效时机
defer语句只有在被声明、入栈的前提下，才会有效，否则，函数退栈时不会被调用，如：
```go
func main() {
defer fmt.Println("A")
return
defer fmt.Println("B") // 由于提前return，此处，defer语句失效
}```
输出顺序：A
2.3后于return语句
defer语句是延迟调用的，但和return语句细比较，return语句先执行，defer语句后执行，如：
```go
func NewTest() int {
fmt.Println("B")
return 0
}
func Test() int {
defer fmt.Println("A")
return NewTest() // 先执行该语句
}
func main() {
Test()
}```
输出顺序：B A
需要注意的是，此处先执行的是return语句，但还没进入函数退栈、修改寄存器的处理步骤。
2.4执行顺序
多个defer语句的执行顺序是FILO，如：
```go
func main() {
defer fmt.Println("A")
defer fmt.Println("B")
fmt.Println("C")
}
输出顺序：C B A
func test() {
for i := 0; i < 4; i++ {
defer fmt.Print(i)
}
}```
2.5嵌套
当defer发生嵌套时，内层的defer也是按照FILO的顺序执行，并且不影响到外层执行顺序，如：
```go
func main() {
defer fmt.Println("A")
defer func() { // defer整体执行顺序保持不变，依据是：
defer fmt.Println("B") // fmt.Println("E")
fmt.Println("C") // func() {}()
defer fmt.Println("D") // fmt.Println("A")
}() // 而// func() {}()内部会继续按照FILO的顺序执行
defer fmt.Println("E")
}```
输出顺序：E C D B A
2.6传参
之前举例中，defer语句中要么没有实参，要么实参取值明确，但在实际调用中，参数传递情况是未知的，如果传的是变量、表达式、函数语句，则会计算出实参结果，在随defer语句入栈。
2.6.1普通变量
defer语句传参中，实参是普通变量，此时，普通变量的取值，就会被压入栈中，如：
```go
func main() {
for index := 0; index < 5; index++{
defer fmt.Printf("%d ", index)
}
}```
输出顺序：4 3 2 1 0
2.6.2指针变量
defer语句传参中，实参是指针变量，此时，指针变量的地址会被压入栈中，而入栈时变量的取值是啥，已经不关注了，关注的是出栈执行时，指针变量的取值，如：
```go
func main() {
for index := 0; index < 5; index++{
defer func(index *int){fmt.Printf("%d ", *index)}(&index)
}
}```
输出顺序：5 5 5 5 5
2.6.3函数语句
defer语句传参中，实参是函数语句，此时，会先执行函数，并将函数的返回值压入栈中，如：
```go
func main() {
f := func(num int)int{
fmt.Printf("%d ", num)
return 10 * num
}
for index := 0; index < 5; index++{
defer fmt.Printf("%d ", f(index)) // 第一循环时，先执行函数f(0)，然后，将函数返回值入栈
}
fmt.Println("")
}```
输出顺序：0 1 2 3 4 40 30 20 10 0
2.7函数返回值
defer语句会影响到函数返回值的结果，此处要先讲一个知识点，对于有返回的函数，return语句执行的处理就是给返回值赋值，如：
```go
func Test() (val int) {
return 2 // 此处执行的处理是 val = 2
}```
2.7.1defer语句操作返回值
defer语句操作函数返回值，此时，返回值的取值会被修改，如：
```go
func Test(val int) (rst int) {
defer func() {
rst += val // 在执行defer语句，对 rst 执行加运算，即 rst = 20 + 10，最终返回值rst取值为30
}()
return 20 // 先执行return语句，对返回值变量rst执行赋值操作，即 rst = 20
}
func main() {
fmt.Println(Test(10))
}```
输出顺序：30
再举个例子，修改返回值是指修改函数语句中的返回值，而不是return语句中的变量，如：
```go
func Test(val int) int { // 返回是int类型，系统会先生成一个临时变量，假设名字是 tmp
rst := val
defer func() {
rst += 20 // 在执行defer语句，对 rst 执行加运算，即 rst = 20 + 10，最终返回值rst取值为30，但tmp还是10
}()
return rst // 执行return语句，即 tmp = rst、 tmp = 10
}
func main() {
fmt.Println(Test(10))
}```
输出顺序：10
2.8配合使用
2.8.1闭包
该种情况是指defer语句的函数体用到外面变量的情况，类似闭包调用，此时，入栈的只有函数地址，不涉及到变量，所以出栈执行时，变量取的是出栈时的值，如：
```go
func main() {
for index := 0; index < 5; index++{
defer func() {fmt.Printf("%d ", index)}()
}
}```
输出顺序：5 5 5 5 5
2.8.2panic
defer常用于异常捕捉，与panic、recover配合使用，处理规则是：defer先与panic声明，当有多个panic时，只有最后一个panic生效，并且recover也捕捉最后一个panic，如：
```go
func main() {
defer func() {
if err := recover(); err != nil{
fmt.Println(err)
}else {
fmt.Println("fatal")
}
}()
defer func() {
panic("defer panic")
}()
panic("main panic")
}```
输出顺序是：defer panic
3.注意
1）defer延迟调用的方式导致其存在浪费内存空间的问题，因为系统需要将defer延迟调用的内容先存下来、然后等函数退栈时再调用，所以defer也要按需使用；
