刚开始的时候理解如何使用Defer和Recover有一点怪异，尤其是使用了try/catch块的时候。有一种模式可以在Go中实现和try/catch语句块一样的效果。不过之前你需要先领会Defer、Panic和Recover的精髓。
首先你需要理解defer关键字的作用，请看如下的代码：
package main import (
"fmt"
) func main() {
test()
} func minicError(key string) error {
return fmt.Errorf("mimic error: %s", key)
} func test() {
fmt.Println("start test") err := minicError("1") defer func() {
fmt.Println("start defer") if err != nil {
fmt.Println("defer error:", err)
}
}() fmt.Println("end test")
}
mimicError方法是一个用来模拟错误的测试方法。这个方法按照Go语言的习惯返回错误。
在Go中错误类型被定义为一个借口：
type error interface {
Error() string
}
如果你现在还理解不了Go的接口，下面的内容会有所帮助。任何实现了Error()方法的类型的变量都可以作为error类型的变量使用。MimicError方法使用errors.New(string)方法创建了一个error类型的变量。errors类型可以在errors包种找到。
测试方法会有如下的输出：
start test
end test
start defer
defer error: mimic error:
仔细观察测试方法的输出你会发现这个方法是什么时候开始，什么时候结束的。在测试方法正常结束前，函数内部的defer方法被调用。两个有趣的事情会发生：首先，defer关键字修饰的方法会在测试方法结束后被调用。其次，由于Go支持使用闭包，err变量可以被内部函数访问，他的错误值“mimic error：1”输出到了stdout。
你可以任意时候在你的函数内部定义一个defer方法。如果那个defer方法需要用到状态，比如上面的代码中的err变量，那么这个变量必须在defer方法定义之前就已经存在。
下面对测试方法稍作修改：
start test
end test
start defer
defer error: mimic error: 2
这个输出和之前的输出几乎没有区别，只修改了一点。这一次的defer方法的输出是“mimic error: 2”。很明显，defer方法对err变量有一个引用。所以如果err变量的状态在defer方法调用前改变了，你就会看到修改之后的值。再次修改defer方法对err变量的引用。这次在测试方法和defer方法中使用err变量的内存地址。
从下面的输出中你会发现，defer方法拥有和测试方法一样的err变量地址。
start test
err address: 0x20818a250
end test
start defer
err address in defer: 0x20818a250
defer error: mimic error: 2
只要defer方法放在测试方法结束前，那么defer方法就一定会被执行。这很好，但是我想要的是每次测试方法在执行的时候defer方法就首先执行。这样就只能把这个方法放在调用方法的最前面。就如Occam所说：“如果你有两个竞争的理论有完全一样的预期，那么更简单的那个就是更好”。我需要的就是一个简单的不需要思考的可行的模式（pattern）。
唯一的问题是err变量需要定义在defer语句的前面。幸运的是Go允许返回的变量直接用于赋值。请看下面修改后的代码：
package main import (
"fmt"
) func main() {
if err := test(); err != nil {
fmt.Printf("mimic error: %v\n", err)
}
} func mimicError(key string) error {
return fmt.Errorf("mimic error: %s", key)
} func test() (err error) {
defer func() {
fmt.Println("start defer") if err != nil {
fmt.Println("defer error:", err)
}
}() fmt.Println("start test") err = mimicError("1") fmt.Println("end test") return err
}
测试方法定义了一个返回类型为error的变量。这样err变量立刻就存在了，并且你可以在defer语句中访问到。同时，test方法也遵循了Go语言的惯例--给调用者返回一个错误类型。
运行这段代码你会得到这样的输出：
start test
end test
start defer
defer error: mimic error: 1
mimic error: mimic error: 1
现在就是时候讨论一下panic了。当Go的任何方法调用了panic的时候，程序的正常执行流程停止。调用panic的方法立刻停止并触发方法调用栈的panic链。所有在同一个调用栈的方法都会一个接一个的停止，就像多米诺骨牌一样。最终panic链会执行到栈顶，然后程序崩溃。一个好的地方是全部存在的defer方法都会在panic序列中执行，并且他们可以停止崩溃。
下面的测试方法调用了内置的panic方法，并且从这一调用中恢复：
仔细看一下defer方法：
defer func() {
fmt.Println("start panic defer")
if r := recover(); r != nil {
fmt.Println("defer panic:", r)
}
}()
defer方法调用了另一个内置的方法叫做recover。这个recover方法阻止了panic触发的奔溃链继续向上调用。recover方法只可以在defer方法中调用，这是因为panic链的方法中只有defer方法可以被执行。
如果recover方法被调用，但是没有任何的panic发生，recover方法只会返回nil。如果有panic发生，那么panic就停止并且给panic的赋值会被返回。上次的代码没有调用MimicError方法，而是用内置的panic方法模拟了一个panic。运行代码后产生的输出：
start test
start defer
defer panic: Mimic Panic
defer方法可以捕获panic，把它打印在屏幕上并停止panic链的继续执行。同时需要注意的是“End Test”没有显示在屏幕上。测试方法在panic调用的时候就立刻停止了。
看起来不错，但是还有一个问题：我还是想显示“End Test”。defer很酷的地方在于你可以在方法里放多余一个的defer方法。
上面的方法可以修改如下：
start test
start defer
defer error: mimic error: 1
start panic defer
defer panic: Mimic Panic
mimic error: mimic error: 1
现在两个defer方法都放在了测试方法的开始部分。第一个defer从panic中recover，之后打印错误。一个需要注意的地方Go语言会按照defer方法定义的反方向执行（先进先出）。
运行之后的输出：
start test
start defer
defer error: mimic error: 1
start panic defer
defer panic: Mimic Panic
mimic error: mimic error: 1
测试方法按照预期的调用了panic停止了测试方法本身的执行。之后处理错误的defer方法被首先执行。由于测试方法在panic之前调用了mimicError方法，所以error可以打印出来。之后recover方法被调用，panic链被中断。
这段代码还是有一个问题。main方法根本不知道panic已经被处理了。main方法只知道发生了一个错误。就是mimicError方法模拟的错误。这可不行。我需要main方法知道引发了panic的错误。这个更是需要报出来的错误。
我们需要在处理panic的defer方法中把panic的错误信息赋值给err变量。现在的输出：
start test
start defer
defer error: mimic error: 1
start panic defer
defer panic: Mimic Panic
mimic error: Mimic Panic
这个时候main函数可以打印出引起panic的错误了。
虽然看起来已经很完美了，但是这个代码不容易扩展。有两个内置的defer方法很酷但是不实用。我需要的是一个单个的，既可以除了错误又可以处理panic的方法。这里是提炼过后的全部代码，叫做_CatchPanic。
package main import (
"fmt"
) func main() {
if err := test(); err != nil {
fmt.Printf("Main error: %v\n", err)
}
} func catchPanic(err error, functionName string) {
if r := recover(); r != nil {
fmt.Printf("%s: PANIC Defered: %v\n", functionName, r) if err != nil {
err = fmt.Errorf("%v", r)
}
}else if err != nil {
fmt.Printf("%s: ERROR: %v\n", functionName, err)
}
} func mimicError(key string) error {
return fmt.Errorf("Mimic Error: %s", key)
} func test() (err error) {
defer catchPanic(err, "Test")
fmt.Println("Start Test") err = mimicError("1") fmt.Println("End Test")
return err
}
新方法catchPanic把错误和panic都处理了。这里主要实用了外部定义defer方法体的方式代替了内部定义方法体。在开始测试以前，我们需要确定不会破坏已有的错误处理。运行代码后的输出：
Start Test
End Test
Main error: Mimic Error: 1
现在我们测试一下panic：
func test() (err error) {
defer catchPanic(err, "Test")
fmt.Println("Start Test")
err = mimicError("1")
panic("Mimic Panic")
// fmt.Println("End Test")
return err
}
输出结果
Start Test
Test: PANIC Defered: Mimic Panic
Main error: Mimic Error: 1
好吧，我们又有一个问题。main方法打印了err变量的信息，而不是panic的内容。那是什么东西出错了呢？
func catchPanic(err error, functionName string) {
if r := recover(); r != nil {
fmt.Printf("%s: PANIC Defered: %v\n", functionName, r)
if err != nil {
err = fmt.Errorf("%v", r)
}
}else if err != nil {
fmt.Printf("%s: ERROR: %v\n", functionName, err)
}
}
因为defer调用的是外部定义的方法。所以没有了inline方法或者闭包的好处。修改代码，打印出测试方法的err地址和_CatchPanic这个defer方法。
func _CatchPanic(err error, functionName string) {
if r := recover(); r != nil {
fmt.Printf("%s: PANIC Defered: %v\n", functionName, r)
fmt.Println("Err addr defer:", &err)
if err != nil {
err = fmt.Errorf("%v", r)
}
}else if err != nil {
fmt.Printf("%s: ERROR: %v\n", functionName, err)
}
}
运行以后你会看到为什么main方法没有得到panic携带的错误：
Err addr: 0x20818c220
Start Test
Test7: PANIC Defered: Mimic Panic
Err addr defer: 0x20818c2b0
Main error: Mimic Error: 1
当测试方法给catchPanic这个defer方法传递err变量的时候，是按照传值引用的方式传递的。在Go语言中，所有的参数都是按照传值方式传递的。因此catchPanic这个defer方法有他独立的err变量的拷贝。任何的对catchPanic所拥有的err的拷贝的修改都只限于这个方法内部。
要修改由传值造成的代码的问题，就需要使用传递引用。
package main import (
"fmt"
) func main() {
if err := testFinal(); err != nil {
fmt.Printf("Main error: %v\n", err)
}
} func _CatchPanic(err *error, functionName string) {
if r := recover(); r != nil {
fmt.Printf("%s: PANIC Defered: %v\n", functionName, r) fmt.Println("Err addr defer:", &err) if err != nil {
*err = fmt.Errorf("%v", r)
}
}else if err != nil && *err != nil {
fmt.Printf("%s: ERROR: %v\n", functionName, *err)
}
} func testFinal() (err error) {
defer _CatchPanic(&err, "TestFinal")
fmt.Printf("Start Test\n") err = minicError("1") panic("Mimic Panic")
} func minicError(key string) error {
return fmt.Errorf("Mimic Error: %s", key)
}
运行代码后输出：
Start Test
TestFinal: PANIC Defered: Mimic Panic
Err addr defer: 0x2081c4020
Main error: Mimic Panic
现在main方法打印出了panic的错误信息。
如果你要捕捉调用栈，需要引用“runtime”包。
使用以上方法就可以处理错误和各种panic的情况。很多情况下，这些情况只是需要记录日志或者在调用栈上处理掉。这样也会有效地降低error并保持代码整洁。然而，我学到的经验是最好只用上面的模式捕捉panic。日志什么的还是留给应用层面的逻辑处理吧。如果不这样，你可能会把错误两次写入日志。
希望这对你学习go语言有帮助！