先来一个最简单的：
package main
import (
"fmt"
)
func f() {
i := 1
fmt.Println("i1 is", i)
defer fmt.Println("i2 is", i)
defer fmt.Println("i3 is", i)
}
func main() {
f()
}结果：
i1 is 1
i3 is 1
i2 is 1
再来看一个简单的：
package main
import (
"fmt"
)
func f() {
i := 1
defer fmt.Println("i2 is", i)
fmt.Println("i1 is", i)
return
defer fmt.Println("i3 is", i)
}
func main() {
f()
}结果：
i1 is 1
i2 is 1
再来看我最近遇到的一个大坑：
package main
import (
"fmt"
)
func f() (i uint32) {
fmt.Println("i1 is", i)
defer fmt.Println("i2 is", i) // 这里不是2
i = 2
return i
}
func main() {
f()
}结果：
i1 is 0
i2 is 0
再来看一个简单的变形：
package main
import (
"fmt"
)
func f() (i uint32) {
fmt.Println("i1 is", i)
defer func() {fmt.Println("i2 is", i)}() // 2
i = 2
return i
}
func main() {
f()
}结果：
i1 is 0
i2 is 2
再来看：
package main
import (
"fmt"
)
func f() (i uint32) {
fmt.Println("i1 is", i)
defer func(i uint32) {fmt.Println("i2 is", i)}(i) // 0
i = 2
return i
}
func main() {
f()
}结果：
i1 is 0
i2 is 0
再看：
package main
import (
"fmt"
)
func f() (i uint32) {
defer func(){
i++
}()
return 0
}
func main() {
fmt.Println(f()) // 1
}结果是：1
再看：
package main
import (
"fmt"
)
func f() (i uint32) {
t := uint32(100)
defer func(){
t = t * 3
}()
return t
}
func main() {
fmt.Println(f()) // 100
}结果是：100
defer的坑很多，使用的时候，要小心， 最后来看一个case:
package main
import (
"fmt"
)
func test1() int {
x := 0
defer func () {
x = 2
}()
x = 1
return x // 这里x为1，先把1赋值给"返回变量tmp", 然后执行x=2, 然后返回"返回变量tmp". 在这种case中，x和“返回变量tmp”不是同一个东东
}
func test2() (x int) {
defer func () {
x = 2
}()
x = 1
return x // 这里x为1，先把1赋值给"返回变量x", 然后执行x=2, 然后返回"返回变量x". 在这种case中，x和“返回变量x”是同一个东东
}
func main(){
i := test1()
fmt.Println("testa:", i) // 1
j := test2()
fmt.Println("testb:", j) // 2
}这里的根本在于理解defer和return的顺序， 并且意识到， 这里的return并非“原子”操作。
好无聊的东西。