一、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
二、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
结论为：return之后的语句先执行，defer后的语句后执行
三、函数的返回值初始化 🔗
package main
import "fmt"
func DeferFunc1(i int) (t int) {
fmt.Println("t = ", t)
return 2
}
func main() {
DeferFunc11(10)
}
// output t=0
证明，只要声明函数的返回值变量名称，就会在函数初始化时候为之赋值为0，而且在函数体作用域可见。
四、有名函数返回值遇见defer情况 🔗
package main
import "fmt"
func returnButDefer() (t int) { //t初始化0， 并且作用域为该函数全域
defer func() {
t = t * 10
}()
return 1
}
func main() {
fmt.Println(returnButDefer())
}
// output t=0
该returnButDefer()本应的返回值是1，但是在return之后，又被defer的匿名func函数执行，所以t=t*10被执行，最后returnButDefer()返回给上层main()的结果为10
五、defer遇见panic 🔗
根据知识点2，我们知道，defer遇见return情况如下：
那么，遇到panic时，遍历本协程的defer链表，并执行defer。在执行defer过程中:遇到recover则停止panic，返回recover处继续往下执行。如果没有遇到recover，遍历完本协程的defer链表后，向stderr抛出panic信息。
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 之后，永远执行不到") }()
}
结果:
// output
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 正常结束
defer 最大的功能是 panic 后依然有效 所以defer可以保证你的一些资源一定会被关闭，从而避免一些异常出现的问题。
六、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捕获到。
七、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))
}
结果:
3
4
2
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
八、defer中的坑 🔗
defer nil函数 🔗
func() {
var run func() = nil
defer run()
fmt.Println("runs")
}
//output
runs
panic: runtime error: invalid memory address or nil pointer dereference
名为 func 的函数一直运行至结束，然后 defer 函数会被执行且会因为值为 nil 而产生 panic 异常。然而值得注意的是，run() 的声明是没有问题，因为在外围函数运行完成后它才会被调用。
循环中使用defer 🔗
慎重在循环中使用defer，因为结果出人意料
func demo(){
for{
row,err:=db.Query("select .....")
if err!=nil{
...
}
defer row.close()
}
}
在上面的例子中，defer row.Close() 在循环中的延迟函数会在函数结束过后运行，而不是每次 for 循环结束之后。这些延迟函数会不停地堆积到延迟调用栈中，最终可能会导致一些不可预知的问题。
解决方案1：不使用defer
func demo(){
for{
row,err:=db.Query("select .....")
if err!=nil{
...
}
row.close()
}
}
解决方案2：移交给函数 这样每次匿名函数执行完，会执行defer
func demo(){
for{
func(){
row,err:=db.Query("select .....")
if err!=nil{
...
}
defer row.close()
}()
}
}
延迟调用含有闭包的函数 🔗
type database struct{}
func (db *database) connect() (disconnect func()) {
fmt.Println("connect")
return func() {
fmt.Println("disconnect")
}
}
//运行
db := &database{}
defer db.connect()
fmt.Println("query db...")
//output
query db...
connect
最终 disconnect 并没有输出，最后只有 connect ，这是一个 bug，最终的情况是 connect() 执行结束后，其执行域得以被保存起来，但内部的闭包并不会被执行。
解决方案
func() {
db := &database{}
close := db.connect()
defer close()
fmt.Println("query db...")
}
在执行块中使用 defer 🔗
想要在执行块执行结束后执行在块内延迟调用的函数，但事实并非如此，它们只会在块所属的函数执行结束后才被执行，这种情况适用于所有的代码块除了上文的函数块例如，for，switch 等
func main() {
{
defer func() {
fmt.Println("block: defer runs")
}()
fmt.Println("block: ends")
}
fmt.Println("main: ends")
}
//output
block: ends
main: ends
block: defer runs
解决方案
func main() {
func() {
defer func() {
fmt.Println("func: defer runs")
}()
fmt.Println("func: ends")
}()
fmt.Println("main: ends")
}