详解golang defer 闭包 匿名函数

//输出结果：return前执行defer
func f1() {
	defer fmt.Println("return前执行defer")
	return
}
 
//输出结果：函数执行
// 函数执行到最后
func f2() {
	defer fmt.Println("函数执行到最后")
	fmt.Println("函数执行")
}
 
//输出结果：panic前  第一个defer在Panic发生时执行，第二个defer在Panic之后声明，不能执行到
func f3() {
	defer fmt.Println("panic前")
	panic("panic中")
	defer fmt.Println("panic后")
}

func f1() int { //匿名返回值
	var r int = 6
	defer func() {
		r *= 7
	}()
	return r
}
 
func f2() (r int) { //有名返回值
	defer func() {
		r *= 7
	}()
	return 6
}
 
func f3() (r int) { //有名返回值
	defer func(r int) {
		r *= 7
	}(r)
	return 6
}

func f1() (r int) {
	r = 6 //给返回值赋值
	func(r int) { //这里改的r是传值传进去的r，不会改变要返回的那个r值
		r *= 7
	}(r)
	return //空的return
}

for i := 0; i <= 3; i++ {
    defer func() {
        fmt.Print(i)
    }
}
//输出结果时 3，3，3，3
因为defer函数的i是对for循环i的引用，defer延迟执行，for循环到最后i是3，到defer执行时i就是3
 
for i := 0; i <= 3; i++ {
    defer func(i int) {
        fmt.Print(i)
    }(i)
}
//输出结果时 3，2，1，0
因为defer函数的i是在defer声明的时候，就当作defer参数传递到defer函数中

func main() {
	/* 匿名函数切片初始化 */
	fns := [](func(x int) int){
		func(x int) int { return x + 1 },
		func(x int) int { return x + 113 },
	}
	println(fns[1](100))
 
	/* 结构体初始化 */
	d := struct {
		fn func() string
	}{
		fn: func() string { return "Hello, World!" },
	}
	println(d.fn())
 
	fc := make(chan func() string, 2)
	fc <- func() string { return "Hello, World!" }
	println((<-fc)())
}

package main
 
import "fmt"
 
func test() func() {
	x := 100
	fmt.Printf("x (%p) = %d\n", &x, x)
 
	return func() {
		fmt.Printf("x (%p) = %d\n", &x, x)
	}
}
 
func main() {
	f := test()
	f()
}