更多关于延迟函数调用的知识点

    在Go中，自定义函数的调用的返回结果都可以被舍弃。但是，大多数内置函数（除了和recover）的调用的返回结果都不可以舍弃（至少对于标准编译器1.13来说是如此）。另一方面，我们已经了解到延迟函数调用的所有返回结果必须都舍弃掉。所以，很多内置函数是不能被延迟调用的。 幸运的是，在实践中，延迟调用内置函数的需求很少见。根据我的经验，只有append函数有时可能会需要被延迟调用。对于这种情形，我们可以延迟调用一个调用了append函数的匿名函数来满足这个需求。

    一个被延迟调用的函数值是在其调用被推入延迟调用堆栈之前被估值的。例如，下面这个例子将输出false。

    1. package main
    3. import "fmt"
    5. func main() {
    6.     var f = func () {
    7.         fmt.Println(false)
    8.     }
    9.     defer f()
    10.     f = func () {
    11.         fmt.Println(true)
    12.     }
    13. }

    一个延迟调用的实参也是在此调用被推入延迟调用堆栈之前估值的。

    一个例子：

    1. import "os"
    3. func withoutDefers(filepath string, head, body []byte) error {
    4.     f, err := os.Open(filepath)
    5.     if err != nil {
    6.         return err
    7.     }
    9.     _, err = f.Seek(16, 0)
    10.     if err != nil {
    11.         f.Close()
    12.         return err
    15.     if err != nil {
    16.         f.Close()
    17.         return err
    18.     }
    20.     _, err = f.Write(body)
    21.     if err != nil {
    22.         f.Close()
    23.         return err
    24.     }
    26.     err = f.Sync()
    27.     f.Close()
    28.     return err
    29. }
    31. func withDefers(filepath string, head, body []byte) error {
    32.     f, err := os.Open(filepath)
    33.     if err != nil {
    34.         return err
    35.     }
    36.     defer f.Close()
    38.     _, err = f.Seek(16, 0)
    39.     if err != nil {
    40.         return err
    41.     }
    43.     if err != nil {
    44.         return err
    47.     _, err = f.Write(body)
    48.     if err != nil {
    49.         return err
    50.     }
    52.     return f.Sync()
    53. }

    上面哪个函数看上去更简洁？显然，第二个使用了延迟调用的函数，虽然只是简洁了些许。另外第二个函数将导致更少的bug，因为第一个函数中含有太多的f.Close()调用，从而有较高的几率漏掉其中一个。 下面是另外一个延迟调用使得代码更鲁棒的例子。如果doSomething函数产生恐慌一个恐慌，则函数f2在退出时将导致互斥锁未解锁。所以函数f1更鲁棒。

    一个较大的延迟调用堆栈可能会消耗很多内存，而且延迟调用堆栈中尚未执行的延迟调用可能会导致某些资源未被及时释放。比如，如果下面的例子中的函数需要处理大量的文件，则在此函数推出之前，将有大量的文件句柄得不到释放。

    1. func writeManyFiles(files []File) error {
    2.     for _, file := range files {
    3.         f, err := os.Open(file.path)
    4.         if err != nil {
    5.             return err
    6.         }
    7.         defer f.Close()
    9.         _, err = f.WriteString(file.content)
    10.         if err != nil {
    11.             return err
    12.         }
    14.         err = f.Sync()
    15.         if err != nil {
    16.             return err
    17.         }
    18.     }
    20. }

    对于这种情形，我们应该使用一个匿名函数将需要及时执行延迟的调用包裹起来。比如，上面的函数可以改进为如下：

    Go语言101项目目前同时托管在Github和上。欢迎各位在这两个项目中通过提交bug和PR的方式来改进完善Go语言101中的各篇文章。