「每周译Go」了解 Go 中的 defer

admin 2023年1月9日22:00:53安全开发评论2 views7323字阅读24分24秒阅读模式

目录

  1. 在 Go 中导入包
  2. 理解 Go 中包的可见性
  3. 如何在 Go 中编写条件语句
  4. 如何在 Go 中编写 Switch 语句
  5. 如何在 Go 中构造 for 循环
  6. 在循环中使用 Break 和 Continue
  7. 如何在 Go 中定义并调用函数
  8. 如何在 Go 中使用可变参数函数
  9. 了解 Go 中的 defer
  10. 了解 Go 中的 init
  11. 用构建标签定制 Go 二进制文件
  12. 了解 Go 中的指针
  13. 在 Go 中定义结构体
  14. 在 Go 中定义方法
  15. 如何构建和安装 Go 程序
  16. 如何在 Go 中使用结构体标签
  17. 如何在 Go 使用 interface
  18. 在不同的操作系统和架构编译 Go 应用
  19. 用 ldflags 设置 Go 应用程序的版本信息
  20. 在 Go 里面如何使用 Flag 包

简介

Go 有许多其他编程语言中常见的控制流关键字,如 ifswitchfor 等。有一个关键词在大多数其他编程语言中都没有,那就是  defer ,虽然它不太常见,但你很快就会发现它在你的程序中是多么有用。

defer 语句的主要用途之一是清理资源,如打开的文件、网络连接和 数据库句柄[1]。当你的程序使用完这些资源后,关闭它们很重要,以避免耗尽程序的限制,并允许其他程序访问这些资源。defer 通过保持关闭文件/资源的调用与打开调用保持一致,使我们的代码更加简洁,不易出错。

在这篇文章中,我们将学习如何正确使用 defer 语句来清理资源,以及使用 defer 时常犯的几个错误。

什么是 defer 语句

defer 语句将 defer 关键字后面的 函数(点击查看哦)调用添加到一个栈中。当该语句所在的函数返回时,将执行堆栈中所有的函数调用。由于这些调用位于堆栈上,因此将按照后进先出的顺序进行调用。

让我们看看 defer 是如何工作的,打印出一些文本:

main.go

package main

import "fmt"

func main() {
        defer fmt.Println("Bye")
        fmt.Println("Hi")
}

main 函数中,我们有两条语句。第一条语句以 defer 关键字开始,后面是 print 语句,打印出 Bye。下一行打印出 Hi

如果我们运行该程序,我们将看到以下输出:

Hi
Bye

请注意,Hi 被首先打印出来。这是因为以 defer 为前缀的语句直到该函数结束前,都不会被调用。

让我们再看看这个程序,这次我们将添加一些注释来帮助说明正在发生的事情:

main.go

package main

import "fmt"

func main() {
        // defer statement is executed, and places
        // fmt.Println("Bye") on a list to be executed prior to the function returning
        defer fmt.Println("Bye")

        // The next line is executed immediately
        fmt.Println("Hi")

        // fmt.Println*("Bye") is now invoked, as we are at the end of the function scope
}

理解 defer 的关键是,当 defer 语句被执行时,延迟函数的参数被立即评估。当 defer 执行时,它把后面的语句放在一个列表中,在函数返回之前被调用。

虽然这段代码说明了 defer 的运行顺序,但这并不是编写 Go 程序时的典型使用方式。我们更可能使用 defer 来清理资源,例如文件句柄。接下来让我们看看如何做到这一点。

使用 defer 来清理资源

使用 defer 来清理资源在 Go 中是非常常见的。让我们先看看一个将字符串写入文件的程序,但没有使用 defer 来处理资源清理的问题:

main.go

package main

import (
        "io"
        "log"
        "os"
)

func main() {
        if err := write("readme.txt""This is a readme file"); err != nil {
                log.Fatal("failed to write file:", err)
        }
}

func write(fileName string, text string) error {
        file, err := os.Create(fileName)
        if err != nil {
                return err
        }
        _, err = io.WriteString(file, text)
        if err != nil {
                return err
        }
        file.Close()
        return nil
}

在这个程序中,有一个叫做 write 的函数,它将首先尝试创建一个文件。如果它有错误,它将返回错误并退出函数。接下来,它试图将字符串 This is a readme file 写到指定文件中。如果它收到一个错误,它将返回错误并退出该函数。然后,该函数将尝试关闭该文件并将资源释放回系统。最后,该函数返回 nil 以表示该函数的执行没有错误。

虽然这段代码可以工作,但有一个细微的错误。如果对 io.WriteString 的调用失败,该函数将在没有关闭文件并将资源释放回系统的情况下返回。

我们可以通过添加另一个 file.Close() 语句来解决这个问题,在没有 defer 的语言中,你可能会这样解决:

main.go

package main

import (
        "io"
        "log"
        "os"
)

func main() {
        if err := write("readme.txt""This is a readme file"); err != nil {
                log.Fatal("failed to write file:", err)
        }
}

func write(fileName string, text string) error {
        file, err := os.Create(fileName)
        if err != nil {
                return err
        }
        _, err = io.WriteString(file, text)
        if err != nil {
                file.Close()
                return err
        }
        file.Close()
        return nil
}

现在,即使调用 io.WriteString 失败了,我们仍然会关闭该文件。虽然这是一个相对容易发现和修复的错误,但对于一个更复杂的函数来说,它可能会被遗漏。

我们可以使用 defer 语句来确保在执行过程中无论采取何种分支,我们都会调用 Close() ,而不是增加对 file.Close() 的第二次调用。

下面是使用 defer 关键字的版本:

main.go

package main

import (
        "io"
        "log"
        "os"
)

func main() {
        if err := write("readme.txt""This is a readme file"); err != nil {
                log.Fatal("failed to write file:", err)
        }
}

func write(fileName string, text string) error {
        file, err := os.Create(fileName)
        if err != nil {
                return err
        }
        defer file.Close()
        _, err = io.WriteString(file, text)
        if err != nil {
                return err
        }
        return nil
}

这一次我们添加了这行代码,defer file.Close()。这告诉编译器,它应该在退出函数 write 之前执行 file.Close

现在我们已经确保,即使我们在未来添加更多的代码并创建另一个退出该函数的分支,我们也会一直清理并关闭该文件。

然而,我们通过添加 defer 引入了另一个错误。我们不再检查可能从 Close 方法返回的潜在错误。这是因为当我们使用 defer 时,没有办法将任何返回值传回给我们的函数。

在 Go 中,在不影响程序行为的情况下多次调用 Close() 被认为是一种安全和公认的做法。如果 Close() 要返回一个错误,它将在第一次被调用时返回。这使得我们可以在函数的成功执行路径中明确地调用它。

让我们看看我们如何既能 deferClose 的调用,又能在遇到错误时报告错误。

main.go

package main

import (
        "io"
        "log"
        "os"
)

func main() {
        if err := write("readme.txt""This is a readme file"); err != nil {
                log.Fatal("failed to write file:", err)
        }
}

func write(fileName string, text string) error {
        file, err := os.Create(fileName)
        if err != nil {
                return err
        }
        defer file.Close()
        _, err = io.WriteString(file, text)
        if err != nil {
                return err
        }

        return file.Close()
}

这个程序中唯一的变化是最后一行,我们返回 file.Close()。如果对 Close 的调用导致错误,现在将按照预期返回给调用函数。请记住,我们的 defer file.Close() 语句也将在 return 语句之后运行。这意味着 file.Close() 有可能被调用两次。虽然这并不理想,但这是可以接受的做法,因为它不应该对你的程序产生任何副作用。

然而,如果我们在函数的早期收到一个错误,例如当我们调用 WriteString 时,函数将返回该错误,并且也将尝试调用 file.Close,因为它被推迟了。尽管 file.Close 也可能(而且很可能)返回一个错误,但这不再是我们关心的事情,因为我们收到的错误更有可能告诉我们一开始就出了什么问题。

到目前为止,我们已经看到我们如何使用一个 defer 来确保我们正确地清理我们的资源。接下来我们将看到如何使用多个 defer 语句来清理多个资源。

多个 defer 语句

在一个函数中拥有多个 defer 语句是很正常的。让我们创建一个只有 defer 语句的程序,看看当我们引入多个 defer 时,会发生什么情况:

main.go

package main

import "fmt"

func main() {
        defer fmt.Println("one")
        defer fmt.Println("two")
        defer fmt.Println("three")
}

如果我们运行该程序,我们将收到以下输出结果:

three
two
one

注意,顺序与我们调用 defer 语句的顺序相反。这是因为每个被调用的延迟语句都是堆叠在前一个语句之上的,然后在函数退出范围时反向调用(后进先出)。

在一个函数中,你可以根据需要有尽可能多的 defer 调用,但重要的是要记住它们都将以相反的顺序被调用。

现在我们了解了多个延迟的执行顺序,让我们看看如何使用多个延迟来清理多个资源。我们将创建一个程序,打开一个文件,向其写入内容,然后再次打开,将内容复制到另一个文件。

main.go

package main

import (
        "fmt"
        "io"
        "log"
        "os"
)

func main() {
        if err := write("sample.txt""This file contains some sample text."); err != nil {
                log.Fatal("failed to create file")
        }

        if err := fileCopy("sample.txt""sample-copy.txt"); err != nil {
                log.Fatal("failed to copy file: %s")
        }
}

func write(fileName string, text string) error {
        file, err := os.Create(fileName)
        if err != nil {
                return err
        }
        defer file.Close()
        _, err = io.WriteString(file, text)
        if err != nil {
                return err
        }

        return file.Close()
}

func fileCopy(source string, destination string) error {
        src, err := os.Open(source)
        if err != nil {
                return err
        }
        defer src.Close()

        dst, err := os.Create(destination)
        if err != nil {
                return err
        }
        defer dst.Close()

        n, err := io.Copy(dst, src)
        if err != nil {
                return err
        }
        fmt.Printf("Copied %d bytes from %s to %sn", n, source, destination)

        if err := src.Close(); err != nil {
                return err
        }

        return dst.Close()
}

我们添加了一个新的函数,叫做 fileCopy。在这个函数中,我们首先打开我们要复制的源文件。我们检查我们是否收到了一个打开文件的错误。如果是的话,我们 return 错误并退出该函数。否则,我们 defer 关闭我们刚刚打开的源文件。

接下来我们创建目标文件。再次,我们检查我们是否收到了创建文件的错误。如果是的话,我们 return 该错误并退出该函数。否则,我们也 defer 目标文件的 Close()。我们现在有两个 defer 函数,当函数退出其作用域时将被调用。

现在我们已经打开了两个文件,我们将Copy() 数据从源文件到目标文件。如果成功的话,我们将尝试关闭两个文件。如果我们在试图关闭任何一个文件时收到错误,我们将 return 错误并退出函数作用域。

注意,我们为每个文件明确地调用 Close(),尽管 defer 也将调用 Close()。这是为了确保如果关闭文件时出现错误,我们会报告这个错误。这也确保了如果因为任何原因函数提前退出,例如我们在两个文件之间复制失败,每个文件仍将尝试从延迟调用中正确关闭。

总结

在这篇文章中,我们了解了 defer 语句,以及如何使用它来确保我们在程序中正确清理系统资源。正确地清理系统资源将使你的程序使用更少的内存,表现更好。要了解更多关于 defer 的使用,请阅读 处理恐慌(点击查看)的文章,或者探索我们整个 《如何在 Go 中编码系列》[2]



相关链接:

[1] https://en.wikipedia.org/wiki/Handle_(computing)
[2] https://gocn.github.io/How-To-Code-in-Go/


往期推荐



「每周译Go」了解 Go 中的 defer

没错,这是2023年开篇!

「每周译Go」了解 Go 中的 defer

「每周译Go」如何在Go中定义并调用函数


「每周译Go」了解 Go 中的 defer

Go1.20新功能:多重错误包装

想要了解Go更多内容,欢迎扫描下方👇关注公众号,回复关键词 [实战群]  ,就有机会进群和我们进行交流

「每周译Go」了解 Go 中的 defer

分享、在看与点赞Go 「每周译Go」了解 Go 中的 defer

原文始发于微信公众号(GoCN):「每周译Go」了解 Go 中的 defer

特别标注: 本站(CN-SEC.COM)所有文章仅供技术研究,若将其信息做其他用途,由用户承担全部法律及连带责任,本站不承担任何法律及连带责任,请遵守中华人民共和国安全法.
  • 我的微信
  • 微信扫一扫
  • weinxin
  • 我的微信公众号
  • 微信扫一扫
  • weinxin
admin
  • 本文由 发表于 2023年1月9日22:00:53
  • 转载请保留本文链接(CN-SEC中文网:感谢原作者辛苦付出):
                  「每周译Go」了解 Go 中的 defer http://cn-sec.com/archives/1507068.html

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: