一文详解go的defer和return的执行顺序

忆拾易行

目录

• 详解go的defer和return的执行顺序
  
  
  
  • defer和return的相互影响
    
  
  

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

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

1. package main
   
2. 
   
3. import "fmt"
   
4. 
   
5. // defer 和 return的详解
   
6. func main() {
   
7.         foo(2)
   
8.         foo(1)
   
9. }
   
10. func foo(i int) {
    
11.         fmt.Println(i)
    
12.         if i == 1 {
    
13.                 return
    
14.         }
    
15.         fmt.Println(i + 1)
    
16. }

复制代码

结果：

1. 231

复制代码

第一次输出完整的输出了i和i+1，第二次输出被短路，只输出了1
defer是golang中的延迟调用，经常用于文件流的关闭，锁的解锁操作，defer后面的操作会在当前函数或者goroutine结束之后进行调用

1. package main
   
2. 
   
3. import "fmt"
   
4. 
   
5. // defer 和 return的详解
   
6. func main() {
   
7.         foo()
   
8. }
   
9. func foo() {
   
10.         defer fmt.Println("println defer")
    
11.         fmt.Println("println foo")
    
12. }
    
13. 
    
14. 输出：
    
15. println foo
    
16. println defer

复制代码

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

1. package main
   
2. 
   
3. import "fmt"
   
4. 
   
5. // defer 和 return的详解
   
6. func main() {
   
7.         foo()
   
8. }
   
9. func foo() {
   
10.         defer fmt.Println("floor 3")
    
11.         defer fmt.Println("floor 2")
    
12.         fmt.Println("floor 1")
    
13. }
    
14. 
    
15. 输出：
    
16. floor 1
    
17. floor 2
    
18. floor 3

复制代码

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

1. ackage main
   
2. 
   
3. import "fmt"
   
4. 
   
5. // defer 和 return的详解
   
6. func main() {
   
7.         foo()
   
8. }
   
9. func foo() {
   
10.         defer func() {
    
11.                 panic("panic test")
    
12.         }()
    
13.         defer func() {
    
14.                 if err := recover(); err != nil {
    
15.                         fmt.Println("catch panic:", err)
    
16.                 }
    
17.         }()
    
18. }
    
19. 
    
20. 输出：
    
21. panic: panic test

复制代码

1. package main
   
2. 
   
3. import "fmt"
   
4. 
   
5. // defer 和 return的详解
   
6. func main() {
   
7.         foo()
   
8. }
   
9. func foo() {
   
10.         defer func() {
    
11.                 if err := recover(); err != nil {
    
12.                         fmt.Println("catch panic:", err)
    
13.                 }
    
14.         }()
    
15.         defer func() {
    
16.                 panic("panic test")
    
17.         }()
    
18. }
    
19. 输出：
    
20. catch panic: panic test

复制代码

defer和return的相互影响

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

1. import "fmt"
   
2. 
   
3. // defer 和 return的详解
   
4. func main() {
   
5.         fmt.Println(foo1())
   
6.         fmt.Println(foo2())
   
7.         fmt.Println(foo3())
   
8. }
   
9. func foo1() int {
   
10.         i := 1
    
11.         defer func() { i++ }()
    
12.         return i
    
13. }
    
14. func foo2() (i int) {
    
15.         i = 1
    
16.         defer func() { i++ }()
    
17.         return i
    
18. }
    
19. func foo3() (i int) {
    
20.         defer func() { i++ }()
    
21.         return 1
    
22. }

复制代码

输出：

1. 122

复制代码

导致上面情况的原因是
在

1. foo1

复制代码

函数中，

1. defer

复制代码

语句中的闭包会在函数返回后执行，但是此时返回值已经确定为

1. 1

复制代码

，所以最终返回

1. 1

复制代码

。
在

1. foo2

复制代码

函数中，使用了命名返回值

1. i

复制代码

。

1. defer

复制代码

语句中的闭包修改的是这个命名返回值，所以返回

1. 2

复制代码

。
在

1. foo3

复制代码

函数中，同样使用了命名返回值

1. i

复制代码

，

1. defer

复制代码

语句中的闭包修改了这个命名返回值，并且函数直接返回

1. 1

复制代码

，但

1. defer

复制代码

中的修改使得最终返回

1. 2

复制代码

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

1. package main
   
2. 
   
3. import "fmt"
   
4. 
   
5. // defer 和 return的详解
   
6. func main() {
   
7.         fmt.Println(foo1())
   
8. 
   
9. }
   
10. func foo1() int {
    
11.         defer func() { fmt.Println("This is defer") }()
    
12.         return func() int {
    
13.                 fmt.Println("This is return")
    
14.                 return 1
    
15.         }()
    
16. }
    
17. 
    
18. 输出：
    
19. This is return
    
20. This is defer
    
21. 1

复制代码

导致上面输出的原因是，return是非原子性的，defer会在return返回值之前执行，但return中的语句，会被全部执行，直到return锚定了某个值或者命名返回值，然后执行defer语句，最后返回return锚定的这个值
到此这篇关于一文详解go的defer和return的执行顺序的文章就介绍到这了,更多相关go defer和return执行顺序内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

唐凝雪

路过，支持一下

逄子美

感谢楼主分享。