调用带有返回后果的内置函数不能被提早调用
在 Go 中，自定义函数的返回值能够被抛弃。然而，对于有返回值的内置函数，返回后果是不能被抛弃的（起码对于 1.17 版本的 Go 编译器是这样的），除了内置 Copy 和 Recover 函数是例外。另一方面，咱们晓得，提早函数的返回值必须抛弃，所以很多内置函数不能当作提早函数应用。
侥幸的是，内置函数 (带有返回值) 在实践中很少应用。据我所知，只有 Append 函数有时候在提早中调用。这种状况，咱们能够将 append 包装到匿名函数中调用。
package main
import "fmt"
func main() {s := []string{"a", "b", "c", "d"}
defer fmt.Println(s) // [a x y d]
// defer append(s[:1], "x", "y") // error
defer func() {_ = append(s[:1], "x", "y")
}()}提早函数求值
将提早函数(值）被推入以后协程提早调用栈时值就被评估。例如上面打印 false:
package main
import "fmt"
func main() {var f = func () {fmt.Println(false)
}
defer f()
f = func () {fmt.Println(true)
}
}提早调用函数的值可能是 nil, 在这种情景下，在被推入到协程提早调用栈中时，nil 函数被调用便会异样，例如：
package main
import "fmt"
func main() {defer fmt.Println("reachable 1")
var f func() // f is nil by default
defer f() // panic here
// The following lines are also reachable.
fmt.Println("reachable 2")
f = func() {} // useless to avoid panicking
}提早函数接管参数求值
就像下面例子，带参数的提早函数求值也是在推入到以后协程提早函数栈之前。
办法接管参数也不例外。例如上面示例返回 1312:
package main
type T int
func (t T) M(n int) T {print(n)
return t
}
func main() {
var t T
// "t.M(1)" is the receiver argument of the method
// call ".M(2)", so it is evaluated before the
// ".M(2)" call is pushed into deferred call stack.
defer t.M(1).M(2)
t.M(3).M(4)
}提早调用使代码更清晰，不容易出错
import "os"
func withoutDefers(filepath string, head, body []byte) error {f, err := os.Open(filepath)
if err != nil {return err}
_, err = f.Seek(16, 0)
if err != nil {f.Close()
return err
}
_, err = f.Write(head)
if err != nil {f.Close()
return err
}
_, err = f.Write(body)
if err != nil {f.Close()
return err
}
err = f.Sync()
f.Close()
return err
}
func withDefers(filepath string, head, body []byte) error {f, err := os.Open(filepath)
if err != nil {return err}
defer f.Close()
_, err = f.Seek(16, 0)
if err != nil {return err}
_, err = f.Write(head)
if err != nil {return err}
_, err = f.Write(body)
if err != nil {return err}
return f.Sync()}哪个看起来更思路清晰？显然带提早调用的，尽管只是一点。对于有很多 f.Close()的函数调用且不应用提早调用极容易漏掉其中一个。
上面的例子展现了提早调用能够缩小很多谬误。如果 doSomething 产生异样，函数 f2 将在锁没有开释的状况下退出。所以 f1 将不会呈现这样的状况：
var m sync.Mutex
func f1() {m.Lock()
defer m.Unlock()
doSomething()}
func f2() {m.Lock()
doSomething()
m.Unlock()}提早调用会造成性能损失
应用提早函数调用并不总是好的。在 Go1.13 之前，提早调用是有一些损失。从 1.13 开始，许多提早调用的提案曾经失去了极大的优化，所以个别状况下，咱们没必要放心提早调用带来的性能损失。感激 Dan Scales 做出的优化。
提早调用导致资源透露
一个很大的提早调用栈会占用很大内存，而且一些异样的异样调用也会造成很多资源不能及时开释。例如：在上面函数中许多文件资源待处理，会有大量的文件解决句柄在期待函数退出后开释：
func writeManyFiles(files []File) error {
for _, file := range files {f, err := os.Open(file.path)
if err != nil {return err}
defer f.Close()
_, err = f.WriteString(file.content)
if err != nil {return err}
err = f.Sync()
if err != nil {return err}
}
return nil
}对于这种状况，咱们能够应用匿名函数来封装提早调用，以便提早函数调用更早执行。能够重写为：
func writeManyFiles(files []File) error {
for _, file := range files {if err := func() error {f, err := os.Open(file.path)
if err != nil {return err}
// The close method will be called at
// the end of the current loop step.
defer f.Close()
_, err = f.WriteString(file.content)
if err != nil {return err}
return f.Sync()}(); err != nil {return err}
}
return nil
}浏览原文