目录1. defer的简单介绍与使用场景2. defer在return执行的时机3. 小结
defer是Go里面的一个关键字，用在方法或函数前面，作为方法或函数的延迟调用。它主要用于以下两个场景：
优雅释放资源，比如一些网络连接、数据库连接以及文件资源的释放。与recover配合处理panic异常
场景一：复制文件
func CopyFile(dstFile, srcFile string) (wr int64, err error) {
src, err :=os.Open(srcFile)
if err !=nil {
return
}
dst, err :=os.Create(dstFile)
if err !=nil {
return
}
wr, err=io.Copy(dst, src)
dst.Close()
src.Close()
return
}
这样的代码是有问题的，当第6行执行失败的时候程序返回但没有关闭前面成功打开的src，资源没有正确关闭，正确代码如下：
（在成功打开资源，没返回err的情况下，都可以使用defer进行优雅的关闭资源）
func CopyFile(dstFile, srcFile string) (wr int64, err error) {
src, err :=os.Open(srcFile)
if err !=nil {
return
}
defer src.Close()
dst, err :=os.Create(dstFile)
if err !=nil {
return
}
defer dst.Close()
wr, err=io.Copy(dst, src)
return err
}
场景二：处理异常panic
package main
import “fmt”
func main() {
defer func() {
if r :=recover(); r !=nil {
fmt.Println(r)
}
}()
a :=1
b :=0
fmt.Println(“result:”, a/b)
}
运行结果：
runtime error: integer divide by zero
程序没有输出result, 会抛出panic, 因为不能对除数为0的数做除法，我们使用defer在程序发生panic的时候捕获异常。go中是用panic抛异常，recover捕获异常，异常会在下一篇go文章进行分析。
通过这两个使用场景我们也可以看到defer后面跟着的函数被调用的时间：
函数return的时候当前协程发生panic的时候
说到延迟函数被调用的时机，这时顺便说一下多个延迟函数被调用时候的执行顺序问题。官方对defer的解释中写到每次defer语句执行的时候，会把函数“压栈”，同时函数参数会被拷贝下来
这两点很重要：
一是说明当一个函数中有多个defer的时候，执行顺序是LIFO先进后出
二是说明延迟函数的参数在defer语句出现时就已经确定下来了
这段代码是用来补充这二点的：看一下能否看懂执行结果，能的话就直接跳到第二部分
func deferRun1() {
var num=1
numptr :=&num
defer fmt.Println(“defer run 1: \n”, numptr, num, *numptr) // 0xc000022088 1 1
defer func() {
fmt.Println(“defer run 2 : \n”, numptr, num, *numptr) // 0xc000116028 2 2
}()
defer func(num int, numptr *int) {
fmt.Println(“defer run 3: \n”, numptr, num, *numptr) //0xc000116028 1 2
}(num, numptr)
num=2
fmt.Println(numptr, num, *numptr) // 0xc000116028 2 2
return
}
对于第一个defer，传入的num和*numptr都是一个具体的值，所以程序return完之后结果会是1,1
对于第二个defer, 没有传入参数，结果会和最后的num和numptr地址对应的内容相同
对于第三个defer, 传入的参数num是固定的值，而numptr是固定的地址，后面地址对应的内容被修改了，所以结果是1,2
同时，执行顺序会是第三个defer先执行，然后是第二个…第一个
第一小节上面说了有一种情况延迟函数的执行是在return的时候，再具体一点就是在return的时候，defer操作带来了什么结果呢？
一句话解决这个问题就是：函数return不是一个原子操作，需要经过以下三步：
设置返回值执行defer将结果返回
一定要牢记在心中，分析的时候也要严格按照这三步来，否则极容易掉坑！
下面把需要注意的情况列举出来：
情况一：延迟函数参数早已固定下来（第一小节提到的重要的一点）
func main() {
deferRun()
deferRun2()
}
func deferRun() {
var num=1
defer fmt.Printf(“num is %d\n”, num)
num=2
return
}
func deferRun2() {
var arr=[4]int{1, 2, 3, 4}
defer printArr(&arr)
arr[0]=100
return
}
func printArr(arr *[4]int) {
for i :=range arr {
fmt.Println(arr[i])
}
}
运行结果为 num is 1 以及 100,2,3,4
道理很简单：延迟函数的参数在defer出现的时候就固定了，对于deferRun，传的参数是num的值，而对于deferRun，传的参数是arr的地址，地址不变，但是地址对应的内容被修改，所以输出被改变。
情况二： 严格把握三步走，绕开 “匿名” 小坑，分析看注释
func main() {
res1 :=deferRun()
fmt.Println(res1)
res2 :=deferRun2()
fmt.Println(res2)
res3 :=deferRun3()
fmt.Println(res3)
res4 :=deferRun4()
fmt.Println(res4)
}
// return 2
func deferRun() (res int) {
num :=1
defer func() {
res++
}()
return num //1.返回值参数res赋值为num即1 //2.执行defer语句，res++ //3. 结果返回2
}
// return 1
func deferRun2() int { // 注意这里返回值是匿名的，我们可以在心里为这个匿名的返回值取名为res
var num int
defer func() {
num++
}()
return 1 //1.匿名返回值参数(res)赋值为1 //2.执行defer语句，num++,加了个寂寞 //3.结果返回1
}
//return 1
func deferRun3() int {
num :=1
defer func() {
num++
}()
return num //1.匿名(res)赋值为num即1 //2.执行defer语句，num++,加了个寂寞，num为2，res依旧为1
//3.结果返回1
}
//return 2
func deferRun4() (res int) {
num :=1
defer func() {
res++
}()
return num //1.返回值参数res赋值为1 //2.执行defer语句，res++ //3.结果返回2
}
执行结果为 2 1 1 2
defer很优雅，可以很简洁的释放资源同时也可以与recover配合进行panic异常的处理
defer定义的延迟函数的参数在defer语句出现的时候就确定下来了，注意有时候确定的是地址
return不是原子操作，包括了三个重要的步骤，顺序是：(注意匿名返回值参数)
设置返回值参数——>执行defer语句——>返回结果
到此这篇关于Golang关键字defer的用法详解的文章就介绍到这了,更多相关Golang关键字defer内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
您可能感兴趣的文章:Golang中的关键字(defer、:=、go?func())详细解读Golang Defer关键字特定操作详解一文搞懂Go语言中defer关键字的使用go语言中的defer关键字Golang的关键字defer的使用方法