golang中的defer关键字

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语句不是原子操作,可以理解为两步

1. 赋值
   在这个例子中,返回值指定了r,所以第一步 r=t
2. 返回
   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)
}