1. 有panic的情况下，panic语句后面的代码不会执行，但是panic语句会在其前面defer语句的后面执行
package main

func main() {

	defer print(123)
	defer_call()
	defer print(789) //panic之后的代码不会被执行
	print("不会执行到这里")
}

func defer_call() {
	defer func() {
		print("打印前")
	}()
	defer func() {
		print("打印中")
	}()

	defer print("打印后")

	panic("触发异常")

	defer print(666)   //IDE会有提示: Unreachable code

}
//打印后打印中打印前123panic: 触发异常
  1. 没有panic的情况下，可以分为四种情况

    1. 在defer内打印父函数的变量，此时可以发现，其实是在操作同一个变量

      func main() {
	deferTest1()
}

func deferTest1() {
	i := 0
	defer func() {
		i--
		fmt.Println("第一个defer", i)
	}()

	i++
	fmt.Println("+1后的i：", i)

	defer func() {
		fmt.Println("第二个defer", i)
	}()

	i++
	fmt.Println("再+1后的i：", i)
	
}

+1后的i： 1
再+1后的i： 2
第二个defer 2
第一个defer 1

    2. 将父函数的变量通过参数传递（值）给了defer, 这种情况其实就是把当前i的值给了defer，后续i再有任何变化都和这个defer没有关系了

      func main() {
	deferTest2()
}

func deferTest2() {
	i := 0
	defer func(k int) {
		fmt.Println("第一个defer", k)
	}(i)

	i++
	fmt.Println("+1后的i：", i)

	defer func(k int) {
		fmt.Println("第二个defer", k)
	}(i)

	i++
	fmt.Println("再+1后的i：", i)

}

+1后的i： 1
再再+1后的i： 2
第二个defer 1  
第一个defer 0

    3. 将父函数的变量通过参数传递（指针）给了defer，同情况1

      func main() {

	deferTest3()
}

func deferTest3() {
	i := 0
	defer func(k *int) {
		fmt.Println("第一个defer", *k)
	}(&i)

	i++
	fmt.Println("+1后的i：", i)

	defer func(k *int) {
		fmt.Println("第二个defer", *k)
	}(&i)
	
	i++
	fmt.Println("再+1后的i：", i)
}

+1后的i： 1
再+1后的i： 2
第二个defer 2
第一个defer 2

    4. 没有匿名函数直接执行一条语句, 同情况2

      func main() {
	rs := deferTest4()
	fmt.Println("main function print:", rs)
}

func deferTest4() int {
	i := 0
	defer fmt.Println("in defer :", i)
	
	i = 1
	fmt.Println("in foo:", i)
	return i+1
}

in foo: 1
in defer : 0          
main function print: 2

defer对返回值的影响

func main() {
	fmt.Println(doubleScore(0))     //0
	fmt.Println(doubleScore(20.0))  //40
	fmt.Println(doubleScore(101.0)) //101
}
func doubleScore(source float32) (rs float32) {
	defer func() {
		if rs < 1 || rs >= 100 {
			//将影响返回值
			rs = source
		}
	}()
	rs = source * 2
	return
}


func main() {
	fmt.Println("foo return :", foo()) //foo return : map[a:b]
}

func foo() map[string]string {

	m := map[string]string{}

	defer func() {
		m["a"] = "b"
	}()

	return m
}