详解go的defer和return之间的执行顺序

go的defer和return是golang中的两个关键子，return用于返回函数的返回值，也可以参与一定的流程控制，比如下面代码，return短路了后面的输出

package main
​
import "fmt"
​
// defer 和 return的详解
func main() {
    foo(2)
    foo(1)
}
func foo(i int) {
    fmt.Println(i)
    if i == 1 {
        return
    }
    fmt.Println(i + 1)
}

结果：

2
3
1

第一次输出完整的输出了i和i+1，第二次输出被短路，只输出了1

defer是golang中的延迟调用，经常用于文件流的关闭，锁的解锁操作，defer后面的操作会在当前函数或者goroutine结束之后进行调用

package main
​
import "fmt"
​
// defer 和 return的详解
func main() {
    foo()
}
func foo() {
    defer fmt.Println("println defer")
    fmt.Println("println foo")
}
​
输出：
println foo
println defer
​

defer自身有一些特性，比如defer和defer之间的执行顺序是先进后出，先defer的最后执行，分析下面代码：

package main
​
import "fmt"
​
// defer 和 return的详解
func main() {
    foo()
}
func foo() {
    defer fmt.Println("floor 3")
    defer fmt.Println("floor 2")
    fmt.Println("floor 1")
}
​
输出：
floor 1
floor 2
floor 3

根据这一特性，如果我们defer调用的代码中存在panic 的可能性，为了保证系统的运行，我们应该在前面recover而不是后面

ackage main
​
import "fmt"
​
// defer 和 return的详解
func main() {
    foo()
}
func foo() {
    defer func() {
        panic("panic test")
    }()
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("catch panic:", err)
        }
    }()
}
​
输出：
panic: panic test

package main
​
import "fmt"
​
// defer 和 return的详解
func main() {
    foo()
}
func foo() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("catch panic:", err)
        }
    }()
    defer func() {
        panic("panic test")
    }()
}
输出：
catch panic: panic test

defer和return的相互影响

defer和return的相互影响，主要是在返回值上表现，考虑下面代码，输出应该是什么：

import "fmt"
​
// defer 和 return的详解
func main() {
    fmt.Println(foo1())
    fmt.Println(foo2())
    fmt.Println(foo3())
}
func foo1() int {
    i := 1
    defer func() { i++ }()
    return i
}
func foo2() (i int) {
    i = 1
    defer func() { i++ }()
    return i
}
func foo3() (i int) {
    defer func() { i++ }()
    return 1
}

输出：

1
2
2

导致上面情况的原因是

在 foo1 函数中，defer 语句中的闭包会在函数返回后执行，但是此时返回值已经确定为 1 ，所以最终返回 1 。

在 foo2 函数中，使用了命名返回值 i 。defer 语句中的闭包修改的是这个命名返回值，所以返回 2 。

在 foo3 函数中，同样使用了命名返回值 i ，defer 语句中的闭包修改了这个命名返回值，并且函数直接返回 1 ，但 defer 中的修改使得最终返回 2 。

而return的另一个特性，也会影响return和defer中代码的执行顺序

package main

import "fmt"

// defer 和 return的详解
func main() {
	fmt.Println(foo1())

}
func foo1() int {
	defer func() { fmt.Println("This is defer") }()
	return func() int {
		fmt.Println("This is return")
		return 1
	}()
}

输出：
This is return
This is defer
1

导致上面输出的原因是，return是非原子性的，defer会在return返回值之前执行，但return中的语句，会被全部执行，直到return锚定了某个值或者命名返回值，然后执行defer语句，最后返回return锚定的这个值