Golang关键字defer的用法详解

 更新时间:2023年05月05日 10:10:21   作者:本生来滑稽  
defer是Go里面的一个关键字,用在方法或函数前面,作为方法或函数的延迟调用。这篇文章主要为大家介绍了defer的简单使用,需要的可以参考一下

1. defer的简单介绍与使用场景

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先执行,然后是第二个...第一个

2. defer在return执行的时机

第一小节上面说了有一种情况延迟函数的执行是在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

3. 小结

defer很优雅,可以很简洁的释放资源同时也可以与recover配合进行panic异常的处理

defer定义的延迟函数的参数在defer语句出现的时候就确定下来了,注意有时候确定的是地址

return不是原子操作,包括了三个重要的步骤,顺序是:(注意匿名返回值参数)

设置返回值参数——>执行defer语句——>返回结果

到此这篇关于Golang关键字defer的用法详解的文章就介绍到这了,更多相关Golang关键字defer内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • Golang学习笔记(三):控制流

    Golang学习笔记(三):控制流

    这篇文章主要介绍了Golang学习笔记(三):控制流,本文讲解了IF、FOR、SWITCH、goto、break、continue等控制流语句的使用实例,需要的朋友可以参考下
    2015-05-05
  • Go中调用JS代码(otto)的实现示例

    Go中调用JS代码(otto)的实现示例

    Otto是一个用Go语言实现的JavaScript解释器,可用于执行和操作JavaScript代码,适合在Go项目中执行简单的JS脚本,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2024-10-10
  • golang中使用匿名结构体的方法

    golang中使用匿名结构体的方法

    这篇文章主要介绍了golang中使用匿名结构体,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2022-08-08
  • Golang实现AES对称加密算法实例详解

    Golang实现AES对称加密算法实例详解

    所谓对称加密是指在加密和解码时使用同一密钥的加密方式,下面这篇文章主要给大家介绍了关于Golang实现AES对称加密算法的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
    2023-02-02
  • Go操作Kafka和Etcd方法详解

    Go操作Kafka和Etcd方法详解

    这篇文章主要为大家介绍了Go操作Kafka和Etcd方法详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-09-09
  • golang HTTP 服务器 处理 日志/Stream流的操作

    golang HTTP 服务器 处理 日志/Stream流的操作

    这篇文章主要介绍了golang HTTP 服务器 处理 日志/Stream流的操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2020-12-12
  • 关于Go你不得不知道的一些实用小技巧

    关于Go你不得不知道的一些实用小技巧

    开发语言上Go成为高并发业务开发的主流语言,再加上云原生技术底座的驱动,Go语言风光无限,下面这篇文章主要给大家介绍了关于Go你不得不知道的一些实用小技巧,需要的朋友可以参考下
    2022-11-11
  • 一文带你探索Go语言中的函数一等公民

    一文带你探索Go语言中的函数一等公民

    你是否听说过 Go 语言中的函数是一等公民,如果没有,那么恭喜你,本文将带你一起揭开这个神秘的面纱,感兴趣的小伙伴快来和小编一起学习起来吧
    2023-07-07
  • Golang中切片的用法与本质详解

    Golang中切片的用法与本质详解

    Go的切片类型为处理同类型数据序列提供一个方便而高效的方式,下面这篇文章就来给大家介绍了关于Golang中切片的用法与本质的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考下
    2018-07-07
  • gin通过go build -tags实现json包切换及库分析

    gin通过go build -tags实现json包切换及库分析

    这篇文章主要为大家介绍了gin通过go build -tags实现json包切换及库分析,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-09-09

最新评论