【Golang】Go语言defer用法大总结(含return返回机制)

最新推荐文章于 2024-02-19 14:57:55 发布
最新推荐文章于 2024-02-19 14:57:55 发布
阅读量7.6k 收藏 42
点赞数 25
分类专栏： Golang 文章标签： go语言 defer go语言return机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cassie_zkq/article/details/108567205
版权

引入

defer是Go语言中的一个关键字（延迟调用），一般用于释放资源和连接、关闭文件、释放锁等。和defer类似的有java的finally和C++的析构函数，这些语句一般是一定会执行的（某些特殊情况后文会提到），不过析构函数析构的是对象，而defer后面一般跟函数或方法。

1、 多个defer语句，按先进后出的方式执行

package main

import "fmt"

func main() {
    var whatever [5]struct{}
    for i := range whatever {
        defer fmt.Println(i)
    }
}

输出：

    4
    3
    2
    1
    0

所有的defer语句会放入栈中，在入栈的时候会进行相关的值拷贝（也就是下面的“对应的参数会实时解析”）。

2、defer声明时，对应的参数会实时解析

简单示例：

package main

import "fmt"

func main() {
	i := 1
	fmt.Println("i =", i)
	defer fmt.Print(i)
}

输出：

i = 1
1

defer后面的语句最后才会执行，后面会讲当defer存在时return的执行逻辑。

辨析：defer后面跟无参函数、有参函数和方法：

package main

import "fmt"

func test(a int) {//无返回值函数
	defer fmt.Println("1、a =", a) //方法
	defer func(v int) { fmt.Println("2、a =", v)} (a) //有参函数
	defer func() { fmt.Println("3、a =", a)} () //无参函数
	a++
}
func main() {
	test(1)
}

输出：

3、a = 2
2、a = 1
1、a = 1

解释：

方法中的参数a，有参函数中的参数v，会请求参数，直接把参数代入，所以输出的都是1。a++变成2之后，3个defer语句以后声明先执行的顺序执行，无参函数中使用的a现在已经是2了，故输出2。

3、可读取函数返回值（return返回机制）

defer、return、返回值三者的执行逻辑应该是：
return最先执行，return负责将结果写入返回值中；
接着defer开始执行一些收尾工作；
最后函数携带当前返回值（可能和最初的返回值不相同）退出。

当defer语句放在return后面时，就不会被执行。如下：

package main

import "fmt"

func f(i int) int{
	return i
	defer fmt.Print("i =", i)
	return i+1
}

func main() {
	f(1)
}

没有输出，因为return i之后函数就已经结束了，不会执行defer。
（1）无名返回值：

package main

import (
	"fmt"
)

func a() int {
	var i int
	defer func() {
		i++
		fmt.Println("defer2:", i) 
	}()
	defer func() {
		i++
		fmt.Println("defer1:", i) 
	}()
	return i
}

func main() {
	fmt.Println("return:", a()) 
}

输出：

defer1: 1
defer2: 2
return: 0

解释：
返回值由变量i赋值，相当于返回值=i=0。第二个defer中i++ = 1， 第一个defer中i++ = 2，所以最终i的值是2。但是返回值已经被赋值了，即使后续修改i也不会影响返回值。最终返回值返回，所以main中打印0。

（2）有名返回值：

package main

import (
	"fmt"
)

func b() (i int) {
	defer func() {
		i++
		fmt.Println("defer2:", i)
	}()
	defer func() {
		i++
		fmt.Println("defer1:", i)
	}()
	return i //或者直接写成return
}

func main() {
	fmt.Println("return:", b())
}

输出：

defer1: 1
defer2: 2
return: 2

解释：
这里已经指明了返回值就是i，所以后续对i进行修改都相当于在修改返回值，所以最终函数的返回值是2。

（3）函数返回值为地址

package main

import (
	"fmt"
)

func c() *int {
	var i int
	defer func() {
		i++
		fmt.Println("defer2:", i)
	}()
	defer func() {
		i++
		fmt.Println("defer1:", i)
	}()
	return &i
}

func main() {
	fmt.Println("return:", *(c()))
}

输出：

defer1: 1
defer2: 2
return: 2

解释：
此时的返回值是一个指针（地址），这个指针=&i，相当于指向变量i所在的地址，两个defer语句都对i进行了修改，那么返回值指向的地址的内容也发生了改变，所以最终的返回值是2。

再看一个例子：

func f() (r int) {
    defer func(r int) {
          r = r + 5
    }(r)
    return 1
}

最初返回值r的值是1，虽然defer语句中函数的参数名也叫r（这里我记作r’），但传参的时候相当于r‘=r（值传递），函数内的语句相当于r’=r‘+5，所以返回值r并没有被修改，最终的返回值仍是1。

4、defer与闭包

package main

import "fmt"

type Test struct {
	name string
}
func (t *Test) pp() {
	fmt.Println(t.name)
}
func main() {
	ts := []Test{{"a"}, {"b"}, {"c"}}
	for _, t := range ts {
		defer t.pp()
	}
}

输出：

c
c
c

解释：
for结束时t.name=“c”，接下来执行的那些defer语句中用到的t.name的值均为”c“。

修改代码为：

package main

import "fmt"

type Test struct {
	name string
}
func pp(t Test) {
	fmt.Println(t.name)
}
func main() {
	ts := []Test{{"a"}, {"b"}, {"c"}}
	for _, t := range ts {
		defer pp(t)
	}
}

输出：

c
b
a

解释：
defer语句中的参数会实时解析，所以在碰到defer语句的时候就把该时的t代入了。

再次修改代码：

package main

import "fmt"

type Test struct {
	name string
}
func (t *Test) pp() {
	fmt.Println(t.name)
}

func main() {
	ts := []Test{{"a"}, {"b"}, {"c"}}
	for _, t := range ts {
		tt := t
		println(&tt)
		defer tt.pp()
	}
}

输出：

0xc000010200
0xc000010210
0xc000010220
c
b
a

解释：

:=用来声明并赋值，连续使用2次a:=1就会报错，但是在for循环内，可以看出每次tt:=t时，tt的地址都不同，说明他们是不同的变量，所以并不会报错。每次都有一个新的变量tt:=t，所以每次在执行defer语句时，对应的tt不是同一个（for循环中实际上生成了3个不同的tt），所以输出的结果也不相同。

5、defer用于关闭文件和互斥锁

文件：

unc ReadFile(filename string) ([]byte, error) {
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer f.close()
    return ReadAll()
}

互斥锁：

var mu sync.Mutex
var m = make(map[string]int)
 
func lookup(key string) int {
    mu.Lock()
    defer mu.Unlock()
    return m[key]
}

6、“解除”对所在函数的依赖

package main

import "fmt"
import "time"

type User struct {
	username string
}

func (this *User) Close() {
	fmt.Println(this.username, "Closed !!!")
}

func main() {
	u1 := &User{"jack"}
	defer u1.Close()
	u2 := &User{"lily"}
	defer u2.Close()
	time.Sleep(10 * time.Second)
	fmt.Println("Done !")

}

输出：

Done !
lily Closed !!!
jack Closed !!!

解释：
defer后面跟无参函数，u1.Close()和u2.Close()要等sleep和fmt.Println(“Done !”)之后才可以执行，也就是在函数最终返回之前执行。

修改代码为：

package main

import "fmt"
import "time"

type User struct {
	username string
}

func (this *User) Close() {
	fmt.Println(this.username, "Closed !!!")
}

func f(u *User) {
	defer u.Close()
}

func main() {
	u1 := &User{"jack"}
	f(u1)
	u2 := &User{"lily"}
	func() { defer u2.Close() }()

	time.Sleep(10 * time.Second)
	fmt.Println("Done !")
}

输出：

jack Closed !!!
lily Closed !!!
Done !

这样的使用方式，似乎不太合理，但却有存在的必要性。大多数情况下，可以用于 u1,u2 之类非常消耗内存，或者cpu，其后执行时间过程且没有太多关联的情况。既保留了defer的功能特性，也满足范围精确控制的条件！（算是奇技淫巧吧😂）

7、defer与panic

（1）在panic语句后面的defer语句不被执行

func panicDefer() {
    panic("panic")
    defer fmt.Println("defer after panic")
}

输出：

panic: panic
goroutine 1 [running]:
main.panicDefer()
    E:/godemo/testdefer.go:17 +0x39
main.main()
    E:/godemo/testdefer.go:13 +0x20
Process finished with exit code 2

可以看到 defer 语句没有执行。
（2）在panic语句前的defer语句会被执行

func deferPanic() {
    defer fmt.Println("defer before panic")
    panic("panic")
}

输出：

defer before panic
panic: panic
goroutine 1 [running]:
main.deferPanic()
    E:/godemo/testdefer.go:19 +0x95
main.main()
    E:/godemo/testdefer.go:14 +0x20
Process finished with exit code 2

defer 语句输出了内容。
Go中的panic类似其它语言中的抛出异常，panic后面的代码不再执行(panic语句前面的defer语句会被执行)。

8、调用os.Exit时defer不会被执行

func deferExit() {
    defer func() {
        fmt.Println("defer")
    }()
    os.Exit(0)
}

当调用os.Exit()方法退出程序时，defer并不会被执行，上面的defer并不会输出。

[参考]：

http://www.topgoer.com/函数/延迟调用defer.html

https://blog.csdn.net/eclipser1987/article/details/12089271

https://www.cnblogs.com/aiandbigdata/p/10822123.html

https://blog.csdn.net/chr1991/article/details/104771526?utm_medium=distribute.pc_relevant.none-task-blog-title-1&spm=1001.2101.3001.4242

https://www.jianshu.com/p/79c029c0bd58

https://blog.csdn.net/qq_21816375/article/details/78161603

_奶酪
关注
  • 25
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang go 语言 领域设计
02-27
golang 领域设计
聊聊golang的defer的使用
01-19
序 本文主要研究一下golang的defer defer return先赋值(对于命名返回值)，然后执行defer，最后函数返回 defer函数调用的执行顺序与它们分别所属的defer语句的执行顺序相反 defer后面的表达式可以是func或者是method的调用，如果defer的函数为nil，则会panic 实例 实例1 // f returns 42 func f() (result int) { defer func() { // result is accessed after it was set to 6 by the return stateme
Golang defer和return执行顺序
最新发布
什么都不会
02-19 415
首先，先了解一下 return 返回值的运行机制：return 并非原子操作，共分为两步操作。其次，defer 的执行顺序是先进后出 FILO，也就是先执行最后一个 defer，最后执行第一个 defer。
GO语言延迟函数defer用法分析
12-26
本文实例讲述了GO语言延迟函数defer用法。分享给大家供大家参考。具体分析如下： defer 在声明时不会立即执行，而是在函数 return 后，再按照 FILO （先进后出）的原则依次执行每一个 defer，一般用于异常处理、释放资源、清理数据、记录日志等。这有点像面向对象语言的析构函数，优雅又简洁，是 Golang 的亮点之一。 代码1：了解 defer 的执行顺序 代码如下:package main import “fmt” func fn(n int) int {  defer func() {   n++   fmt.Println(“3st:”, n)  }()  defer
golang中defer的关键特性示例详解
12-31
前言 大家都知道golang的defer关键字，它可以在函数返回前执行一些操作，最常用的就是打开一个资源（例如一个文件、数据库连接等）时就用defer延迟关闭改资源，以免引起内存泄漏。本文主要给大家介绍了关于golang中defer的关键特性，分享出来供大家参考学习，下面话不多说，来一起看看详细的介绍： 一、defer 的作用和执行时机 go 的 defer 语句是用来延迟执行函数的，而且延迟发生在调用函数 return 之后，比如 func a() int { defer b() return 0 } b 的执行是发生在 return 0 之后，注意 defer 的语法，关键字 de
Golang巧用defer进行错误处理的方法
12-31
本文主要跟大家介绍了Golang巧用defer进行错误处理的相关内容，分享出来供大家参考学习，下面来看看详细的介绍： 问题引入 毫无疑问，错误处理是程序的重要组成部分，有效且优雅的处理错误是大多数程序员的追求。很多程序员都有C/C++的编程背景，Golang的程序员也不例外，他们处理错误有意无意的带着C/C++的烙印。 我们看看下面的例子，就有一种似曾相识的赶脚，代码如下： func deferDemo() error { err := createResource1() if err != nil { return ERR_CREATE_RESOURCE1_FAILED } er
Go语言中defer和return解析
刘贤松的博客
04-15 3176
// Go语言中函数的return不是原子操作，在底层是分为两步来执行 // 第一步：返回值赋值 // defer // 第二步：真正的RET返回 // 函数中如果存在defer，那么defer执行的时机是在第一步和第二步之间
Golang - return 和 defer
yang_kaiyue的博客
06-11 254
return的原理, defer的执行时机
理解Golang中defer的使用
热门推荐
huang_yong_peng的博客
10-06 2万+
之前一直对Go中的defer不太理解，所以我单独弄出来整理一下。 在golang当中，defer代码块会在函数调用链表中增加一个函数调用。这个函数调用不是普通的函数调用，而是会在函数正常返回，也就是return之后添加一个函数调用。因此，defer通常用来释放函数内部变量。 通过defer，我们可以在代码中优雅的关闭/清理代码中所使用的变量。defer作为golang清理变量的特性，有其独有且明确...
golang return defer的返回值问题
qq_15115793的博客
08-18 1407
package main import "fmt" //验证golang return defer 的返回值 func main() { fmt.Println("let's go !!!") i1 := test1() fmt.Println("main1", i1, &i1) fmt.Println("=============================") i2 := test2() fmt.Println("main2", i2, &i2) } func
Golang中defer、return、返回值之间执行顺序笔记
chilv的专栏
12-29 3045
package main import "fmt" func main() { fmt.Println("return a ", a()) fmt.Println("---------------------------------------") b1,b2 := b() fmt.Println("return b ", b1, b2) fmt.Println("--------...
golang中defer的使用规则详解
01-21
前言 在golang当中，defer代码块会在函数调用链表中增加一个函数调用。这个函数调用不是普通的函数调用，而是会在函数正常返回，也就是return之后添加一个函数调用。因此，defer通常用来释放函数内部变量。 为了更好的学习defer的行为，我们首先来看下面一段代码: func CopyFile(dstName, srcName string) (written int64, err error) { src, err := os.Open(srcName) if err != nil { return } dst, err := os.Create(dstName) if err !
总结Go语言中defer的使用和注意要点
09-21
Go语言中的defer关键字实现比较特殊的功能，这篇文章给大家总结了关于Go语言中defer的使用和注意要点，有需要的朋友们可以参考借鉴，下面来一起看看吧。
大家一起学Golang——Go语言简介与安装
01-08
大家一起学Golang ——Go语言简介与安装 go语言简介 Go语言是有google公司推出的一门编程语言，是开源，静态编程语言，语法简洁，天生支持并发。 2007年由Robert Griesemer, Rob Pike, Ken Thompson主持开发，又来加入了Ian Lance Taylor, Russ Cox等⼈，在2009年11⽉开源。 go语言特点 简洁 快速 安全 并行 开源 内存管理 数组安全 编译迅速 go语言方向 网络编程领域 区块链开发领域 高性能分布式系统领域 Go语言拥较高效的开发速度，编译迅速(最初开发go语言的大牛都有c语言背景，Go语言语法简洁，似乎可以找到
golang善用go func和defer
01-07
一、error与panic： error：可预见的错误 panic：不可预见的错误，panic一般通过defer中的recover()捕获 对于有风险的代码，若发生panic则会导致程序异常退出，例如数组越界。 1. panic的操守 panic是有秩序的，退出之前会执行完先处理完当前goroutine已经defer【挂上去】的任务，若某个defer在panic之后，则不会被执行。 panic仅保证当前goroutine下的defer都会被调到，但不保证其他协程的defer也会调到 同一goroutine下的已经挂上去的多个defer，回溯执行，即先进后出 例如： func main() {
MySQL.zip_Go_ Go_ Go!_go mysql_go 语言_golang_go语言
09-21
Go语言mysql驱动库，用于go语言的mysql链接
Golang_Puzzlers.zip_Go_ Go_ Go!_golang_go语言核心36讲
09-23
Go语言深入教材,深入理解golang的运行机制
golang读取文件的常用方法总结
01-03
使用go语言读取文件的各种方式整理。 一次性加载到内存中 // * 整个文件读到内存，适用于文件较小的情况 //每次读取固定字节 //问题容易出现乱码，因为中文和中文符号不占一个字符 func readAllIntoMemory(filename...
golang快速入门[2.1]-go语言开发环境配置-windows
01-07
golang快速入门[2.1]-go语言开发环境配置-windows 接下来，我们将讲解在windows、linux、macos三大平台上配置go语言的开发环境。 windows安装Go语言开发包 配置go语言的开发环境的第一步是要在go官网下载页面下载...
go语言 defer关键字示例代码
04-25
好的，下面是一个go语言的defer关键字示例代码： ``` package main import "fmt" func main() { defer fmt.Println("1") defer fmt.Println("2") defer fmt.Println("3") fmt.Println("done") } ``` 这个代码会输出： ``` done 3 2 1 ``` 这是因为defer关键字会延迟函数的执行，直到函数返回之前才会执行。在这个例子中，三个defer语句会在main函数返回之前按照从后往前的顺序执行，因此会先输出3，然后是2，最后是1。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值