Golang之defer 延迟调用操作

前言

defer语句被用于预定对一个函数的调用。我们把这类被defer语句调用的函数称为延迟函数。而defer 延迟语句在其他编程语言里好像没有见到。应该是属于 Go 语言里的独有的关键字。但用法类似于面向对象编程语言 Java 和 C# 的 finally 语句块。

下面对defer进行介绍。

defer特性

1. 关键字 defer 用于注册延迟调用。

2. 这些调用直到 return 前才被执。因此,可以用来做资源清理。

3. 多个defer语句,按先进后出的方式执行。

1.延迟调用

用法很简单,只需要在函数前面加上 defer就行,就能实现将这个 该函数的调用延迟到当前函数执行完后再执行。例如:

package main
import (
 "fmt"
)
func myFunc(){
 fmt.Println("minger")
}
func main(){
 defer myFunc() //等价于defer fmt.Println("minger")
 fmt.Println("程序猿编码")
}

编译运行:

2.defer 与 return 孰先孰后

defer 和 return 到底是哪个先调用?先看看例子:

package main
import (
 "fmt"
)
var name string = "go"
func myFunc() string {
  defer func() {
    name = "python"
  }()
  fmt.Println("myFunc 函数里的name:", name)
  return name
}
func main() {
  myName := myFunc()
  fmt.Println("main 函数里的name: ", name)
  fmt.Println("main 函数里的myname: ", myName )

编译运行:

来看看打印信息,第一行输出,name 此时还是全局变量,值还是go

第二行输出,在 defer 里改变了全局变量,此时name的值已经变成了 python

重点在第三行,为什么输出的是 go ?

解释只有一个,那就是 defer 是return 后才调用的。所以在执行 defer 前,myName 已经被赋值成 go 了。

3.多个defer 逆序执行

还是老规矩先来上代码,看看输出信息,例子:

package main
import (
 "fmt"
)
func main(){
 name := "go"
 defer fmt.Println(name)
 name = "C/C++"
 defer fmt.Println(name)
 name = "Python"
 fmt.Println(name)
}

编译输出:

可见 多个defer 是它们会以逆序执行(类似栈,即后进先出)。

defer官方的解释

Each time a “defer” statement executes, the function value and parameters to the call are evaluated as usual and saved anew but the actual function is not invoked. Instead, deferred functions are invoked immediately before the surrounding function returns, in the reverse order they were deferred. If a deferred function value evaluates to nil, execution panics when the function is invoked, not when the “defer” statement is executed.

翻译一下:

每次defer语句执行的时候,会把函数“压栈”,函数参数会被拷贝下来;当外层函数(非代码块,如一个for循环)退出时,defer函数按照定义的逆序执行;如果defer执行的函数为nil, 那么会在最终调用函数的产生panic.

为什么需要defer?

往往我们在编程的时候,经常需要打开一些资源,比如数据库连接、文件、锁等,这些资源需要在用完之后释放掉,否则会造成内存泄漏。

因此我们有时会忘记关闭这些资源。Golang直接在语言层面提供defer关键字,在打开资源语句的下一行,就可以直接用defer语句来注册函数结束后执行关闭资源的操作。

defer用途

1. 关闭文件句柄

2. 锁资源释放

3. 数据库连接释放

defer的使用其实非常简单,来看看一个简单用途:

package main
import (
 "log"
 "os"
)
func main() {
 f, err := os.OpenFile("text.txt", os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666) //文件没有就创建,文件存在就追加
 if err != nil {
 log.Fatal(err)
 }
 defer f.Close()
 f.WriteString("程序猿编码\n")
}

编译输出:

在打开文件的语句附近,用defer语句关闭文件。这样,在函数结束之前,会自动执行defer后面的语句来关闭文件。

当然,defer会有小小地延迟,对时间要求特别特别特别高的程序,可以避免使用它。

总结

defer 语句经常使用于成对的操作,比如打开和关闭,连接和断开,加锁和解锁,即便是再复杂的控制流,资源在任何情况下都能够正确释放。

补充:Golang中defer的三个实战要点

前言

Golang中的defer是使用频次比较高的,能创造出延迟生效特效的一种方式。

defer也有自己的矫情,需要注意的。

本文将从通过代码的方式来说明defer的三点矫情。

1.defer的生效顺序

2.defer与return,函数返回值之间的顺序

3.defer定义和执行两个步骤,做的事情。

正文

1.defer的生效顺序

先说结论:defer的执行顺序是倒序执行(同入栈先进后出)

func main() {
 defer func() {
 fmt.Println("我后出来")
 }()
 defer func() {
 fmt.Println("我先出来")
 }()
}

执行后打印出:

我先出来

我后出来

2.defer与return,函数返回值之间的顺序

先说结论:return最先执行->return负责将结果写入返回值中->接着defer开始执行一些收尾工作->最后函数携带当前返回值退出

返回值的表达方式,我们知道根据是否提前声明有两种方式:一种是func test() int 另一种是 func test() (i int),所以两种情况都来说说

func test() int
func main() {
 fmt.Println("main:", test())
}
func test() int {
 var i int
 defer func() {
 i++
 fmt.Println("defer2的值:", i)
 }()
 defer func() {
 i++
 fmt.Println("defer1的值:", i)
 }()
 return i
}

输出:

defer1的值: 1

defer2的值: 2

main: 0

详解:return的时候已经先将返回值给定义下来了,就是0,由于i是在函数内部声明所以即使在defer中进行了++操作,也不会影响return的时候做的决定。

func test() (i int)
func main() {
 fmt.Println("main:", test())
}
func test() (i int) {
 defer func() {
 i++
 fmt.Println("defer2的值:", i)
 }()
 defer func() {
 i++
 fmt.Println("defer1的值:", i)
 }()
 return i
}

输出:

defer1的值: 1

defer2的值: 2

main: 2

详解:由于返回值提前声明了,所以在return的时候决定的返回值还是0,但是后面两个defer执行后进行了两次++,将i的值变为2,待defer执行完后,函数将i值进行了返回。

3.defer定义和执行两个步骤,做的事情

先说结论:会先将defer后函数的参数部分的值(或者地址)给先下来【你可以理解为()里头的会先确定】,后面函数执行完,才会执行defer后函数的{}中的逻辑

func test(i *int) int {
 return *i
}
func main(){
 var i = 1
 // defer定义的时候test(&i)的值就已经定了,是1,后面就不会变了
 defer fmt.Println("i1 =" , test(&i))
 i++
 // defer定义的时候test(&i)的值就已经定了,是2,后面就不会变了
 defer fmt.Println("i2 =" , test(&i))
 // defer定义的时候,i就已经确定了是一个指针类型,地址上的值变了,这里跟着变
 defer func(i *int) {
 fmt.Println("i3 =" , *i)
 }(&i)
 // defer定义的时候i的值就已经定了,是2,后面就不会变了
 defer func(i int) {
 //defer 在定义的时候就定了
 fmt.Println("i4 =" , i)
 }(i)
 defer func() {
 // 地址,所以后续跟着变
 var c = &i
 fmt.Println("i5 =" , *c)
 }()

 // 执行了 i=11 后才调用,此时i值已是11
 defer func() {
 fmt.Println("i6 =" , i)
 }()
 i = 11
}

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。如有错误或未考虑完全的地方,望不吝赐教。

(0)

相关推荐

  • Golang巧用defer进行错误处理的方法

    本文主要跟大家介绍了Golang巧用defer进行错误处理的相关内容,分享出来供大家参考学习,下面来看看详细的介绍: 问题引入 毫无疑问,错误处理是程序的重要组成部分,有效且优雅的处理错误是大多数程序员的追求.很多程序员都有C/C++的编程背景,Golang的程序员也不例外,他们处理错误有意无意的带着C/C++的烙印. 我们看看下面的例子,就有一种似曾相识的赶脚,代码如下: func deferDemo() error { err := createResource1() if err != n

  • golang中defer的使用规则详解

    前言 在golang当中,defer代码块会在函数调用链表中增加一个函数调用.这个函数调用不是普通的函数调用,而是会在函数正常返回,也就是return之后添加一个函数调用.因此,defer通常用来释放函数内部变量. 为了更好的学习defer的行为,我们首先来看下面一段代码: func CopyFile(dstName, srcName string) (written int64, err error) { src, err := os.Open(srcName) if err != nil {

  • Golang学习笔记之延迟函数(defer)的使用小结

    golang的defer优雅又简洁, 是golang的亮点之一.defer在声明时不会立即执行,而是在函数return后,再按照先进后出的原则依次执行每个defer,一般用于释放资源.清理数据.记录日志.异常处理等. 关键字defer于注册延迟调用.这些调用直到 ret 前才被执行,通常用于释放资源或错误处理. 一.当defer被声明时,其参数就会被实时解析 func a() { i := 0 defer fmt.Println(i) //输出0,因为i此时就是0 i++ defer fmt.P

  • Golang之defer 延迟调用操作

    前言 defer语句被用于预定对一个函数的调用.我们把这类被defer语句调用的函数称为延迟函数.而defer 延迟语句在其他编程语言里好像没有见到.应该是属于 Go 语言里的独有的关键字.但用法类似于面向对象编程语言 Java 和 C# 的 finally 语句块. 下面对defer进行介绍. defer特性 1. 关键字 defer 用于注册延迟调用. 2. 这些调用直到 return 前才被执.因此,可以用来做资源清理. 3. 多个defer语句,按先进后出的方式执行. 1.延迟调用 用法

  • Go语言中init函数和defer延迟调用关键词详解

    Go语言中init函数和defer延迟调用关键词 golang里面有两个保留函数 main 函数(只能应用于package main) init 函数(能够应用于所有的package) go程序会自动调用 init()和main() 所以你不能在任何地方调用这两个函数 package main 必须包含一个main 函数,但是每个package中的init函数都是可选的 一个package 里可以写多个init函数,建议每个包中只写一个init函数 单个包中代码执行顺序如下 main包 -->

  • Golang Defer关键字特定操作详解

    Go语言中的defer关键字用于在函数返回前执行一些特定的操作.可以将defer看作是一种后置语句,在函数中的任何位置都可以使用. 下面是一个使用defer的例子: func foo() { defer fmt.Println("Done") fmt.Println("Hello") } 在上面的例子中,当函数foo被调用时,它会先输出"Hello",然后再输出"Done",因为"Done"被包装在defe

  • golang中defer的关键特性示例详解

    前言 大家都知道golang的defer关键字,它可以在函数返回前执行一些操作,最常用的就是打开一个资源(例如一个文件.数据库连接等)时就用defer延迟关闭改资源,以免引起内存泄漏.本文主要给大家介绍了关于golang中defer的关键特性,分享出来供大家参考学习,下面话不多说,来一起看看详细的介绍: 一.defer 的作用和执行时机 go 的 defer 语句是用来延迟执行函数的,而且延迟发生在调用函数 return 之后,比如 func a() int { defer b() return

  • Golang 的defer执行规则说明

    defer介绍 defer是golang的一个特色功能,被称为"延迟调用函数".当外部函数返回后执行defer.类似于其他语言的 try- catch - finally- 中的finally,当然差别还是明显的. 在使用defer之前我们应该多了解defer的特性,这样才能避免使用上的误区. 1. 最简单的defer func test(){ defer func(){ fmt.Println("defer") }() //todo //... return //

  • 简单聊聊Golang中defer预计算参数

    目录 什么是defer Go语言defer预计算参数 总结 什么是defer defer用来声明一个延迟函数,把这个函数放入到一个栈上, 当外部的包含方法return之前,返回参数到调用方法之前调用,也可以说是运行到最外层方法体的"}"时调用.我们经常用他来做一些资源的释放,比如关闭io操作 func doSomething(fileName string) { file,err := os.Open(fileName) if err != nil { panic(err) } def

  • golang中defer的基本使用教程

    目录 前言 1.什么是defer 2.defer的特点 3.defer什么时间执行 4.defer常见的坑 1.输出是多少? 2.输出多少 3.输出多少 4.输出什么 总结 前言 第一次看go基础语法的时候,用使用到了defer.但是一直不知道它到底是什么,有什么用途.这几天通过查询.学习.算是对defer有了一点浅显的认识. 1.什么是defer defer是go中一种延迟调用机制,defer后面的函数只有在当前函数执行完毕后才能执行,通常用于释放资源. 2.defer的特点 defer遵循先

  • Golang通过SSH执行交换机操作实现

    简单实现通过输入指令,两步执行交换机命令. 输入执行换机的账号和密码.可以一次输入多个账号和密码,为了方便操作,规定了输入格式.如 用户名:主机IP;密码|用户名:主机IP;密码.举例admin;192.168.56.10;h3csw1|admin;192.168.56.11;h3csw2 输入要执行的命令,以;分割.例如system-view;dis cu; ​ 存在问题: 不够灵活.输入方式限制太死,输入特别字符也可能存在错误. 过于简陋. 功能简单. ​ 不过我的目的已经达到,我主要是了解

  • golang连接sqlx库的操作使用指南

    目录 安装sqlx 基本使用 连接数据库 查询 插入.更新和删除 NamedExec NamedQuery 事务操作 sqlx.In的批量插入示例 表结构 结构体 bindvars(绑定变量) 自己拼接语句实现批量插入 使用sqlx.In实现批量插入 使用NamedExec实现批量插入 sqlx.In的查询示例 in查询 in查询和FIND_IN_SET函数 sqlx库使用指南 在项目中我们通常可能会使用database/sql连接MySQL数据库.本文借助使用sqlx实现批量插入数据的例子,介

  • Go语言函数的延迟调用(Deferred Code)详解

    目录 基本功能 示例一:延迟调用执行顺序 示例二:多defer使用方法 实例三:defer与局部变量.返回值的关系 先解释一下这篇Blog延期的原因,本来已经准备好了全部内容,但是当我重新回顾实例三的时候,发现自己还是存在认知不足的地方,于是为了准确表述,查阅了大量的资料,重新编写了第三部分,导致延期.感谢持续关注本笔记更新的朋友,后期我将逐步通过3-5分钟视频方式为大家对笔记内容进行讲解,帮助更多的朋友能够快速掌握Go语言的基础. 本节将介绍Go语言函数和方法中的延迟调用,正如名称一样,这部分

随机推荐