golang什么时候用panic（如何深入理解Golang中的defer）

golang什么时候用panic（如何深入理解Golang中的defer）func a() { i := 0 defer fmt.Println(i) i return } 2. 在外层函数返回后，以后进先出顺序（LIFO）执行延迟函数调用。在此示例中，在延迟调用Println时调用表达式“i”，函数返回后，defer 调用将打印“0”。func CopyFile(dstName srcName string) (written int64 err error) { src err := os.Open(srcName) if err != nil { return } defer src.Close() dst err := os.Create(dstName) if err != nil { return } defer dst.Close() return io.Copy(dst src) } defer 语句允

Go具有控制流程的常用机制：if，for，switch，goto。它还有go语句在单独的goroutine中运行代码。在这里，我想讨论一些不太常见的问题：defer panic and recover。

一个defer语句会将一个函数调用入栈到列表中，在外层函数返回后执行已保存调用的列表。defer 通常用于简化执行各种清理操作的功能。

例如，让我们看一个函数，打开两个文件并将一个文件的内容复制到另一个文件：

func CopyFile(dstName srcName string) (written int64 err error) { src err := os.Open(srcName) if err != nil { return } dst err := os.Create(dstName) if err != nil { return } written err = io.Copy(dst src) dst.Close() src.Close() return }

这有效，但有一个bug。如果对os.Create的调用失败，该函数将返回而没有关闭源文件。这个问题可以通过在第二个return语句之前调用src.Close来轻松解决，但如果函数更复杂，则问题可能不会那么容易被注意到并解决。通过引入 defer 语句，我们可以确保文件始终关闭：

func CopyFile(dstName srcName string) (written int64 err error) { src err := os.Open(srcName) if err != nil { return } defer src.Close() dst err := os.Create(dstName) if err != nil { return } defer dst.Close() return io.Copy(dst src) }

defer 语句允许我们在打开每个文件之后立即关闭它，以保证无论函数中的返回语句数量如何，文件都将被关闭。

defer 语句的行为是直截了当且可预测的。这里，有三个简单的使用规则：

1. 当执行 defer 语句时，defer 函数的参数已经被调用。

在此示例中，在延迟调用Println时调用表达式“i”，函数返回后，defer 调用将打印“0”。

func a() { i := 0 defer fmt.Println(i) i return }

2. 在外层函数返回后，以后进先出顺序（LIFO）执行延迟函数调用。

此函数打印“3210”：

func b() { for i := 0; i < 4; i { defer fmt.Print(i) } }

3. derfer 函数可以读取并分配给返回函数的命名返回值。

在此示例中，defer 函数在周围函数返回后递增返回值i 。因此，此函数返回2：

func c() (i int) { defer func() { i }() return 1 }

这样便于修改函数的错误返回值; 我们很快就会看到一个例子。

Panic 是一种内置函数，可以阻止普通的控制流并开始 panic。当函数F调用 panic 时，F的执行停止，F中的任何 defer 函数都正常执行，然后F返回其调用者。对于调用者，F然后表现得像是对 panic 的呼唤。该过程继续向上传递，直到当前 goroutine 中的所有函数都返回，此时程序崩溃。可以通过直接调用 panic 来启动 panic。它们也可能由运行时错误引起，例如越界数组访问。

Recover 是一个内置函数，可以重新控制 panic 的 goroutine。恢复仅在延迟函数内有用。在正常执行期间，对recover的调用将返回nil并且没有其他效果。如果当前 goroutine 处于恐慌状态，则对恢复的调用将捕获给予恐慌的值并恢复正常执行。

这是一个演示 panic 和 defer 机制的示例程序：

package main import "fmt" func main() { f() fmt.Println("Returned normally from f.") } func f() { defer func() { if r := recover(); r != nil { fmt.Println("Recovered in f" r) } }() fmt.Println("Calling g.") g(0) fmt.Println("Returned normally from g.") } func g(i int) { if i > 3 { fmt.Println("Panicking!") panic(fmt.Sprintf("%v" i)) } defer fmt.Println("Defer in g" i) fmt.Println("Printing in g" i) g(i 1) }

函数g取int i，如果i大于3则发生 panic，否则它用参数i 1调用自身。函数f执行一个调用recover并打印恢复值的函数（如果它是非零的）。在阅读之前尝试描绘该程序的输出可能是什么。

该程序将输出：

Calling g. Printing in g 0 Printing in g 1 Printing in g 2 Printing in g 3 Panicking! Defer in g 3 Defer in g 2 Defer in g 1 Defer in g 0 Recovered in f 4 Returned normally from f.

如果我们从f中删除延迟函数，则不会恢复恐慌并到达goroutine调用堆栈的顶部，从而终止程序。此修改后的程序将输出：

Calling g. Printing in g 0 Printing in g 1 Printing in g 2 Printing in g 3 Panicking! Defer in g 3 Defer in g 2 Defer in g 1 Defer in g 0 panic: 4 [stack trace omitted]

有关panic和recover的真实示例，请参阅Go标准库中的JSON包。它使用一组递归函数对JSON编码的数据进行解码。当遇到格式错误的JSON时，解析器调用panic将堆栈展开到顶级函数调用，该函数调用从恐慌中恢复并返回适当的错误值（请参阅 decode.go 中的decodeState类型的'error'和'unmarshal'方法）。

Go库中的约定是，即使包在内部使用panic，其外部API仍然会显示明确的错误返回值。

defer 的其他用法包括释放互斥锁：

mu.Lock（） defer mu.Unlock（）

打印页脚：

printHeader() defer printFooter()

总之，defer 语句（有或没有 panic 和 recover）为控制流提供了一种不寻常且强大的机制，它可用于模拟由其他编程语言中的专用结构实现的许多功能，试试看吧。