defer关键字将函数调用计划到外层函数返回时执行，典型的用法就是互斥锁释放，文件关闭。这样的函数是不会因为随着返回分支的数量变多而忘记关闭。
但是defer的执行特定如果没有了解的话，很容易掉坑里。
多个defer的执行顺序
首先,对于下述例子,输出为何
for i := 0; i < 5; i++ {
defer fmt.Printf("%d ", i)
}
首先说明，函数存在多个defer语句，调用的时的顺序为FILO,可以想想成压栈处理,即吧defer的调用先存入栈中,然后调用时在一个个出栈执行.
明白这个，答案就很明白了
4 3 2 1 0
带参defer的问题
考虑下述程序执行
func trace(s string) string {
fmt.Println("entering:", s)
return s
}
func un(s string) {
fmt.Println("leaving:", s)
}
func a() {
defer un(trace("a"))
fmt.Println("in a")
}
func b() {
defer un(trace("b"))
fmt.Println("in b")
a()
}
func main() {
b()
}
写下答案，
标准答案为
entering: b
in b
entering: a
in a
leaving: a
leaving: b
道理其实很简单(知道了之后~~),defer语句调用的函数的参数不是在调用时才确定,而是在程序执行到这条语句是就确定了。
所以上述函数b中执行到 defer un(trace("b"))时，会首先确定un函数的参数,即执行trace("b")
一些例子
一
func b(t int ) (r int){
defer func() {t=t+1}()
return t
}
func main() {
fmt.Println(b(1))
}
output// 1
这个需要知道,go中return语句不是原子操作,可以理解为两步
- 赋值
在这个例子中,返回值指定了r,所以第一步 r=t - 返回
return r
关键在于defer的执行时机,他是在这两步中间执行的。
二
这个是由开篇的例子引出
具体
for i := 0; i < 5; i++ {
defer func(){ fmt.Printf("%d ", i)}
}
output// 55555
for i := 0; i < 5; i++ {
defer func(n int){ fmt.Printf("%d ", n)(i)}
}
output//01234
经典闭包问题,go中函数调用都是值拷贝,for循环中i始终是一个地址,所以联系到上边说的，defer函数调用参数实在语句执行时候确定的,所以传入的始终是i的地址的值。类似还有结构体的for-range
type field struct {
name string
}
func (p *field) print() {
fmt.Println(p.name)
}
func main() {
data := []field{{"one"},{"two"},{"three"}}
1/////
for _,v := range data {
defer v.print()
} //goroutines print: three, three, three
2
for _,v := range data {
v := v
defer v.print()
}three two one
time.Sleep(3 * time.Second)
}
有疑问加站长微信联系（非本文作者）
