一、错误和异常的区别
错误指的是可能出现问题的地方出现了问题。比如打开一个文件时失败，这种情况在人们的意料之中 。
异常指的是不应该出现问题的地方出现了问题。比如引用了空指针，这种情况在人们的意料之外。
可见，错误是业务过程的一部分，而异常不是 。
二、错误演示
go语言中，错误是一种数据类型，使用内置的error类型，和其他数据类型一样使用。
package main
import (
"fmt"
"os"
)
func main() {
_, err := os.Open("a.txt")
if err != nil {
fmt.Println(err)
return
}
fmt.Println("open file success")
}
运行结果
open a.txt: The system cannot find the file specified.
三、错误类型
go语言通过内置的error接口提供了非常简单的错误处理机制。
type error interface {
Error() string
}
这个接口中包含一个Error() string，任何实现了该方法的类型都可以作为一个错误使用。这个方法提供了错误的描述。
打印错误是，fmt.Println函数在内部调用Error()方法来获取错误的描述。
从错误中提取更多信息的方法：
1、断言底层结构体类型并从结构体字段中获取更多的信息。
查看go语言源码，可以发现上面的示例中打开文件的代码中返回值error实现类error接口，可以看做error类型，但这个返回值error本身是PathError结构体类型。
go语言源码：
// PathError records an error and the operation and file path that caused it.
type PathError struct {
Op string
Path string
Err error
}
func (e *PathError) Error() string { return e.Op + " " + e.Path + ": " + e.Err.Error() }
func (e *PathError) Unwrap() error { return e.Err }
// Timeout reports whether this error represents a timeout.
func (e *PathError) Timeout() bool {
t, ok := e.Err.(timeout)
return ok && t.Timeout()
}
通过类型断言，可以将error作为PathError类型的实例，访问其属性和方法。
示例：
package main
import (
"fmt"
"os"
)
func main() {
_, err := os.Open("a.txt")
if err != nil {
if err, ok := err.(*os.PathError); ok {
fmt.Println(err.Op) // open
fmt.Println(err.Path) // a.txt
fmt.Println(err.Err) // The system cannot find the file specified.
}
return
}
fmt.Println("open file success")
}
2、断言底层结构体类型，调用其方法获取更多信息
go语言源码：
type DNSError struct {
...
}
func (e *DNSError) Error() string {
...
}
func (e *DNSError) Timeout() bool {
...
}
func (e *DNSError) Temporary() bool {
...
}
DNSError struct有两个方法Timeout() bool和Temporary() bool，它们返回一个布尔值，表示错误是由于超时还是临时的。
示例：
package main
import (
"fmt"
"net"
)
func main() {
add, err := net.LookupHost("www.baiddfudfsadf.com")
if err != nil {
if err, ok := err.(*net.DNSError); ok {
if err.Timeout() {
fmt.Println("operation time out")
} else if err.Temporary() {
fmt.Println("temporary error")
} else {
fmt.Println("genration error", err)
}
}
return
}
fmt.Println(add)
}
运行结果
genration error lookup www.baiddfudfsadf.com: no such host
四、自定义错误
1、使用errors包下的New()函数
go语言源码：
// Package errors implements functions to manipulate errors.
package errors
// New returns an error that formats as the given text.
func New(text string) error {
return &errorString{text}
}
// errorString is a trivial implementation of error.
type errorString struct {
s string
}
func (e *errorString) Error() string {
return e.s
}
示例：
package main
import (
"errors"
"fmt"
"math"
)
func main() {
s := -4.2
res, err := squareArea(s)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("squareArea =", res)
}
func squareArea(sideLength float64) (float64, error) {
if sideLength < 0 {
return 0, errors.New("sideLength < 0")
}
return math.Pow(sideLength, 2), nil
}
运行结果
sideLength < 0
2、使用fmt包下的Errorf()函数
go语言源码：
func Errorf(format string, a ...interface{}) error {}
示例：
package main
import (
"fmt"
"math"
)
func main() {
s := -4.2
res, err := squareArea(s)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("squareArea =", res)
}
func squareArea(sideLength float64) (float64, error) {
if sideLength < 0 {
return 0, fmt.Errorf("sideLength < 0, sideLength = %v
", sideLength)
}
return math.Pow(sideLength, 2), nil
}
运行结果
sideLength < 0, sideLength = -4.2
3、使用struct类型属性和方法提供更多关于错误的信息。
示例：
package main
import (
"fmt"
)
// areaError 结构体 错误类型
type areaError struct {
err string
length float64
width float64
}
// Error() 方法，实现error接口
func (e *areaError) Error() string {
return fmt.Sprintf("length: %v, %v, error: %v", e.length, e.width, e.err)
}
func (e *areaError) lengthNegative() bool {
return e.length < 0
}
func (e *areaError) widthNegative() bool {
return e.width < 0
}
func main() {
length := -10.2
width := 3.4
res, err := rectangleArea(length, width)
if err != nil {
fmt.Println("err:", err)
if err, ok := err.(*areaError); ok {
if err.lengthNegative() {
fmt.Println("length < 0", err.length)
}
if err.widthNegative() {
fmt.Println("width < 0", err.width)
}
}
}
fmt.Println("rectangle area =", res)
}
func rectangleArea(length, width float64) (float64, error) {
err := ""
if length < 0 {
err += "length < 0"
}
if width < 0 {
if length < 0 {
err += "&width < 0"
} else {
err = "width < 0"
}
}
if err != "" {
return 0, &areaError{err, length, width}
}
return length * width, nil
}
运行结果
err: length: -10.2, 3.4, error: length < 0
length < 0 -10.2
rectangle area = 0
五、panic和recover
Golang中引入两个内置函数panic和recover来触发和终止异常处理流程，同时引入关键字defer来延迟执行defer后面的函数。
panic：
- 1、内建函数
- 2、假如函数F中书写了panic语句，会终止其后要执行的代码，在panic所在函数F内如果存在要执行的defer函数列表，按照defer的逆序执行
- 3、返回函数F的调用者G，在G中，调用函数F语句之后的代码不会执行，假如函数G中存在要执行的defer函数列表，按照defer的逆序执行，这里的defer 有点类似 try-catch-finally 中的 finally
- 4、直到goroutine整个退出，并报告错误
recover：
- 1、内建函数
- 2、用来控制一个goroutine的panicking行为，捕获panic，从而影响应用的行为
- 3、一般的调用建议
a). 在defer函数中，通过recever来终止一个gojroutine的panicking过程，从而恢复正常代码的执行
b). 可以获取通过panic传递的error
以下给出异常处理的作用域（场景）：
- 空指针引用
- 下标越界
- 除数为0
- 不应该出现的分支，比如default
- 输入不应该引起函数错误
六、错误处理的正确姿势
姿势一：失败的原因只有一个时，不使用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
错误示例：
func (self *CniParam) setTenantId() error {
self.TenantId = self.PodNs
return nil
}
正确示例：
func (self *CniParam) setTenantId() {
self.TenantId = self.PodNs
}
姿势三：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！！！"
- ...
姿势五：错误逐层传递时，层层都加日志
层层都加日志非常方便故障定位。
说明：至于通过测试来发现故障，而不是日志，目前很多团队还很难做到。如果你或你的团队能做到，那么请忽略这个姿势。
姿势六：错误处理使用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函数会返回可以读取的字节数以及错误信息。对于这种情况，应该将读取到的字符串和错误信息一起打印出来。
说明：对函数的返回值要有清晰的说明，以便于其他人使用。
七、异常处理的正确姿势
姿势一：在程序开发阶段，坚持速错
速错，简单来讲就是“让它挂”，只有挂了你才会第一时间知道错误。在早期开发以及任何发布阶段之前，最简单的同时也可能是最好的方法是调用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 {/ 打印 && 错误处理 /}"代码块）。