1.1 错误处理的正确姿势
姿势一：失败的原因只有一个时，不使用error
我们看一个案例：
func (self *AgentContext) CheckHostType(host_type string) error { switch host_type { case "virtual_machine": return nil case "bare_metal": return nil } return errors.New("CheckHostType ERROR:" + host_type) } 我们可以看出，该函数失败的原因只有一个，所以返回值的类型应该为bool，而不是error，重构一下代码：
func (self *AgentContext) IsValidHostType(hostType string) bool { return hostType == "virtual_machine" || hostType == "bare_metal" } 说明：大多数情况，导致失败的原因不止一种，尤其是对I/O操作而言，用户需要了解更多的错误信息，这时的返回值类型不再是简单的bool，而是error。
姿势二：没有失败时，不使用error
error在Golang中是如此的流行，以至于很多人设计函数时不管三七二十一都使用error，即使没有一个失败原因。
我们看一下示例代码：
func (self *CniParam) setTenantId() error { self.TenantId = self.PodNs return nil } 对于上面的函数设计，就会有下面的调用代码：
err := self.setTenantId() if err != nil { // log // free resource return errors.New(...) } 根据我们的正确姿势，重构一下代码：
func (self *CniParam) setTenantId() { self.TenantId = self.PodNs } 于是调用代码变为：
self.setTenantId()
姿势三：error应放在返回值类型列表的最后
对于返回值类型error，用来传递错误信息，在Golang中通常放在最后一个。
resp, err := http.Get(url) if err != nil { return nill, err } bool作为返回值类型时也一样。
value, ok := cache.Lookup(key) if !ok { // ...cache[key] does not exist… } 姿势四：错误值统一定义，而不是跟着感觉走
很多人写代码时，到处return errors.New(value)，而错误value在表达同一个含义时也可能形式不同，比如“记录不存在”的错误value可能为：
- "record is not existed."
- "record is not exist!"
- "###record is not existed！！！"
- …
这使得相同的错误value撒在一大片代码里，当上层函数要对特定错误value进行统一处理时，需要漫游所有下层代码，以保证错误value统一，不幸的是有时会有漏网之鱼，而且这种方式严重阻碍了错误value的重构。
于是，我们可以参考C/C++的错误码定义文件，在Golang的每个包中增加一个错误对象定义文件，如下所示：
var ERR_EOF = errors.New("EOF") var ERR_CLOSED_PIPE = errors.New("io: read/write on closed pipe") var ERR_NO_PROGRESS = errors.New("multiple Read calls return no data or error") var ERR_SHORT_BUFFER = errors.New("short buffer") var ERR_SHORT_WRITE = errors.New("short write") var ERR_UNEXPECTED_EOF = errors.New("unexpected EOF") 姿势五：错误逐层传递时，层层都加日志
层层都加日志非常方便故障定位。
说明：至于通过测试来发现故障，而不是日志，目前很多团队还很难做到。如果你或你的团队能做到，那么请忽略这个姿势。
姿势六：错误处理使用defer
我们一般通过判断error的值来处理错误，如果当前操作失败，需要将本函数中已经create的资源destroy掉，示例代码如下：
func deferDemo() error { err := createResource1() if err != nil { return ERR_CREATE_RESOURCE1_FAILED } err = createResource2() if err != nil { destroyResource1() return ERR_CREATE_RESOURCE2_FAILED } err = createResource3() if err != nil { destroyResource1() destroyResource2() return ERR_CREATE_RESOURCE3_FAILED } err = createResource4() if err != nil { destroyResource1() destroyResource2() destroyResource3() return ERR_CREATE_RESOURCE4_FAILED } return nil } 当Golang的代码执行时，如果遇到defer的闭包调用，则压入堆栈。当函数返回时，会按照后进先出的顺序调用闭包。
对于闭包的参数是值传递，而对于外部变量却是引用传递，所以闭包中的外部变量err的值就变成外部函数返回时最新的err值。
根据这个结论，我们重构上面的示例代码：
func deferDemo() error { err := createResource1() if err != nil { return ERR_CREATE_RESOURCE1_FAILED } defer func() { if err != nil { destroyResource1() } }() err = createResource2() if err != nil { return ERR_CREATE_RESOURCE2_FAILED } defer func() { if err != nil { destroyResource2() } }() err = createResource3() if err != nil { return ERR_CREATE_RESOURCE3_FAILED } defer func() { if err != nil { destroyResource3() } }() err = createResource4() if err != nil { return ERR_CREATE_RESOURCE4_FAILED } return nil } 姿势七：当尝试几次可以避免失败时，不要立即返回错误
如果错误的发生是偶然性的，或由不可预知的问题导致。一个明智的选择是重新尝试失败的操作，有时第二次或第三次尝试时会成功。在重试时，我们需要限制重试的时间间隔或重试的次数，防止无限制的重试。
两个案例：
- 我们平时上网时，尝试请求某个URL，有时第一次没有响应，当我们再次刷新时，就有了惊喜。
- 团队的一个QA曾经建议当Neutron的attach操作失败时，最好尝试三次，这在当时的环境下验证果然是有效的。
姿势八：当上层函数不关心错误时，建议不返回error
对于一些资源清理相关的函数（destroy/delete/clear），如果子函数出错，打印日志即可，而无需将错误进一步反馈到上层函数，因为一般情况下，上层函数是不关心执行结果的，或者即使关心也无能为力，于是我们建议将相关函数设计为不返回error。
姿势九：当发生错误时，不忽略有用的返回值
通常，当函数返回non-nil的error时，其他的返回值是未定义的(undefined)，这些未定义的返回值应该被忽略。然而，有少部分函数在发生错误时，仍然会返回一些有用的返回值。比如，当读取文件发生错误时，Read函数会返回可以读取的字节数以及错误信息。对于这种情况，应该将读取到的字符串和错误信息一起打印出来。
说明：对函数的返回值要有清晰的说明，以便于其他人使用。
1.2 异常处理的正确姿势
姿势一：在程序开发阶段，坚持速错
速错，简单来讲就是“让它挂”，只有挂了你才会第一时间知道错误。在早期开发以及任何发布阶段之前，最简单的同时也可能是最好的方法是调用panic函数来中断程序的执行以强制发生错误，使得该错误不会被忽略，因而能够被尽快修复。
姿势二：在程序部署后，应恢复异常避免程序终止
在Golang中，某个Goroutine如果panic了，并且没有recover，那么整个Golang进程就会异常退出。所以，一旦Golang程序部署后，在任何情况下发生的异常都不应该导致程序异常退出，我们在上层函数中加一个延迟执行的recover调用来达到这个目的，并且是否进行recover需要根据环境变量或配置文件来定，默认需要recover。
这个姿势类似于C语言中的断言，但还是有区别：一般在Release版本中，断言被定义为空而失效，但需要有if校验存在进行异常保护，尽管契约式设计中不建议这样做。在Golang中，recover完全可以终止异常展开过程，省时省力。
我们在调用recover的延迟函数中以最合理的方式响应该异常：
- 打印堆栈的异常调用信息和关键的业务信息，以便这些问题保留可见；
- 将异常转换为错误，以便调用者让程序恢复到健康状态并继续安全运行。
我们看一个简单的例子：
func funcA() error { defer func() { if p := recover(); p != nil { fmt.Printf("panic recover! p: %v", p) debug.PrintStack() } }() return funcB() } func funcB() error { // simulation panic("foo") return errors.New("success") } func test() { err := funcA() if err == nil { fmt.Printf("err is nil\\n") } else { fmt.Printf("err is %v\\n", err) } } 我们期望test函数的输出是：
err is foo
实际上test函数的输出是：
err is nil
原因是panic异常处理机制不会自动将错误信息传递给error，所以要在funcA函数中进行显式的传递，代码如下所示：
func funcA() (err error) { defer func() { if p := recover(); p != nil { fmt.Println("panic recover! p:", p) str, ok := p.(string) if ok { err = errors.New(str) } else { err = errors.New("panic") } debug.PrintStack() } }() return funcB() } 姿势三：对于不应该出现的分支，使用异常处理
当某些不应该发生的场景发生时，我们就应该调用panic函数来触发异常。比如，当程序到达了某条逻辑上不可能到达的路径：
switch s := suit(drawCard()); s { case "Spades": // ... case "Hearts": // ... case "Diamonds": // ... case "Clubs": // ... default: panic(fmt.Sprintf("invalid suit %v", s)) } 姿势四：针对入参不应该有问题的函数，使用panic设计
入参不应该有问题一般指的是硬编码，我们先看这两个函数（Compile和MustCompile），其中MustCompile函数是对Compile函数的包装：
func MustCompile(str string) *Regexp { regexp, error := Compile(str) if error != nil { panic(regexp: Compile( + quote(str) + ): + error.Error()) } return regexp } 所以，对于同时支持用户输入场景和硬编码场景的情况，一般支持硬编码场景的函数是对支持用户输入场景函数的包装。
对于只支持硬编码单一场景的情况，函数设计时直接使用panic，即返回值类型列表中不会有error，这使得函数的调用处理非常方便（没有了乏味的"if err != nil {/ 打印 && 错误处理 /}"代码块）。