1：defer的执行顺序
多个defer出现的时候，它是一个“栈”的关系，也就是先进后出。一个函数中，写在前面的defer会比写在后面的defer调用的晚
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")
}
输出结果
C
B
A
2: defer与return谁先谁后
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()
}
执行结果为：
return func called
defer func called
3：函数的返回值初始化
package main
import "fmt"
func DeferFunc1(i int) (t int) {
fmt.Println("t = ", t)
return 2
}
func main() {
DeferFunc11(10)
}
结果
0
4: 有名函数返回值遇见defer情况
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
10
5: defer遇见panic，但是并不捕获异常的情况
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 之后，永远执行不到") }()
}
defer: panic 之前2
defer: panic 之前1
panic: 异常内容
....
defer遇见panic，并捕获异常
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 之后, 永远执行不到") }()
}
defer: panic 之前2, 不捕获
defer: panic 之前1, 捕获异常
异常内容
main 正常结束
6:defer中包含panic
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")
}
defer panic
分析
panic仅有最后一个可以被revover捕获。
触发panic("panic")后defer顺序出栈执行，第一个被执行的defer中 会有panic("defer panic")异常语句，这个异常将会覆盖掉main中的异常panic("panic")，最后这个异常被第二个执行的defer捕获到。
7: defer下的函数参数包含子函数
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
输出：
3
4
2
1
defer真题
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
将返回值t赋值为传入的i，此时t为1
执行return语句将t赋值给t（等于啥也没做）
执行defer方法，将t + 3 = 4
函数返回 4
因为t的作用域为整个函数所以修改有效。
DeferFunc2
创建变量t并赋值为1
执行return语句，注意这里是将t赋值给返回值，此时返回值为1（这个返回值并不是t）
执行defer方法，将t + 3 = 4
函数返回返回值1
DeferFunc3
首先执行return将返回值t赋值为2
执行defer方法将t + 1
最后返回 3
DeferFunc4
初始化返回值t为零值 0
首先执行defer的第一步，赋值defer中的func入参t为0
执行defer的第二步，将defer压栈
将t赋值为1
执行return语句，将返回值t赋值为2
执行defer的第三步，出栈并执行
因为在入栈时defer执行的func的入参已经赋值了，此时它作为的是一个形式参数，所以打印为0；相对应的因为最后已经将t的值修改为2，所以再打印一个2
输出：
4
1
3
0
2