Go自学第八节Go错误和异常捕获以和处理

程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常

golang中提供了两种处理异常的方式

• 一种是程序发生异常时, 将异常信息反馈给使用者

• 一种是程序发生异常时, 立刻退出终止程序继续运行

Go中提供了两种创建异常信息的方式。

方式一: 通过fmt包中的Errorf函数创建错误信息, 然后打印

1.  
    
2.  
   package main
3.  
   import "fmt"
4.  
   func main() {
5.  
   // 1.创建错误信息
6.  
   var err error = fmt.Errorf("这里是错误信息")
7.  
   // 2.打印错误信息
8.  
   fmt.Println(err) // 这里是错误信息
9.  
   }

方式二: 通过errors包中的New函数创建错误信息,然后打印

1.  
   package main
2.  
   import "fmt"
3.  
   func main() {
4.  
   // 1.创建错误信息
5.  
   var err error = errors.New("这里是错误信息")
6.  
   // 2.打印错误信息
7.  
   fmt.Println(err) // 这里是错误信息
8.  
   }

 我们可以看到，和两种方法本质上都是一个error的接口类型接收了错误信息，error接口的源码如下

1.  
   package builtin
2.  
   // 定义了一个名称叫做error的接口
3.  
   // 接口中声明了一个叫做Error() 的方法
4.  
   type error interface {
5.  
   Error() string
6.  
   }

在errors包中定义了一个名称叫做做errorString的结构体, 利用这个结构体实现了error接口中指定的方法

并且在errors 包中还提供了一个New方法, 用于创建实现了error接口的结构体对象, 并且在创建时就会把指定的字符串传递给这个结构体

1.  
   // 指定包名为errors
2.  
   package errors
3.  
   // 定义了一个名称叫做errorString的结构体, 里面有一个字符串类型属性s
4.  
   type errorString struct {
5.  
   s string
6.  
   }
7.  
   // 实现了error接口中的Error方法
8.  
   // 内部直接将结构体中保存的字符串返回
9.  
   func (e *errorString) Error() string {
10.  
    return e.s
11.  
    }
12.  
    // 定义了一个New函数, 用于创建异常信息
13.  
    // 注意: New函数的返回值是一个接口类型
14.  
    func New(text string) error {
15.  
    // 返回一个创建好的errorString结构体地址
16.  
    return &errorString{text}
17.  
    }

fmt包中Errorf底层的实现原理其实就是在内部自动调用了errors包中的New函数

1.  
   func Errorf(format string, a ...interface{}) error {
2.  
   return errors.New(Sprintf(format, a...))
3.  
   }

 我们可以自己写一个可以实现Error接口的结构体，并自行输出错误结果

1.  
   // 定义一个 DivideError 结构
2.  
   type DivideError struct {
3.  
   dividee int
4.  
   divider int
5.  
   }
6.  
    
7.  
   // 实现 `error` 接口
8.  
   func (de *DivideError) Error() string {
9.  
   strFormat := `
10.  
    Cannot proceed, the divider is zero.
11.  
    dividee: %d
12.  
    divider: 0
13.  
    `
14.  
    return fmt.Sprintf(strFormat, de.dividee)
15.  
    }
16.  
     
17.  
    // 定义 `int` 类型除法运算的函数
18.  
    func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
19.  
    if varDivider == 0 {
20.  
    dData := DivideError{
21.  
    dividee: varDividee,
22.  
    divider: varDivider,
23.  
    }
24.  
    errorMsg = dData.Error()
25.  
    return
26.  
    } else {
27.  
    return varDividee / varDivider, ""
28.  
    }
29.  
     
30.  
    }
31.  
     
32.  
    func main() {
33.  
     
34.  
    // 正常情况
35.  
    if result, errorMsg := Divide(100, 10); errorMsg == "" {
36.  
    fmt.Println("100/10 = ", result)
37.  
    }
38.  
    // 当除数为零的时候会返回错误信息
39.  
    if _, errorMsg := Divide(100, 0); errorMsg != "" {
40.  
    fmt.Println("errorMsg is: ", errorMsg)
41.  
    }
42.  
     
43.  
    }

输出结果如下

1.  
   100/10 = 10
2.  
   errorMsg is:
3.  
   Cannot proceed, the divider is zero.
4.  
   dividee: 100
5.  
   divider: 0

中断程序

Go语言中提供了一个叫做panic函数, 用于发生异常时终止程序继续运行

Go语言中有两种方式可以触发panic终止程序

• 我们自己手动调用panic函数

• 程序内部出现问题自动触发panic函数

1.  
   package main
2.  
   import "fmt"
3.  
   func div(a, b int) (res int) {
4.  
   if(b == 0){
5.  
   //一旦传入的除数为0, 程序就会终止
6.  
   panic("除数不能为0")
7.  
   }else{
8.  
   res = a / b
9.  
   }
10.  
    return
11.  
    }
12.  
    func main() {
13.  
    res := div(10, 0)
14.  
    fmt.Println(res)
15.  
    }

控制台输出 

1.  
   panic: 除数不能为0
2.  
    
3.  
   goroutine 1 [running]:
4.  
   main.div(...)
5.  
   /Users/weber/GolandProjects/awesomeProject/error.go:8
6.  
   main.main()
7.  
   /Users/weber/GolandProjects/awesomeProject/error.go:15 0x2c

恢复程序

• 发生panic后，程序会从调用panic的函数位置或发生panic的地方立即返回，逐层向上执行函数的defer语句，然后逐层打印函数调用堆栈，直到被recover捕获或运行到最外层函数。
• panic不但可以在函数正常流程中抛出，在defer逻辑里也可以再次调用panic或抛出panic。defer里面的panic能够被后续执行的defer捕获。
• recover用来捕获panic，阻止panic继续向上传递。recover()和defer一起使用，但是defer只有在后面的函数体内直接被掉用才能捕获panic来终止异常，否则返回nil，异常继续向外传递。

1.  
   func div(a, b int) (res int) {
2.  
   // 定义一个延迟调用的函数, 用于捕获panic异常
3.  
   // 注意: 一定要在panic之前定义
4.  
   defer func() {
5.  
   if err := recover(); err != nil {
6.  
   res = -1
7.  
   fmt.Println(err) // 除数不能为0
8.  
   }
9.  
   }()
10.  
    if b == 0 {
11.  
    //err = errors.New("除数不能为0")
12.  
    panic("除数不能为0")
13.  
    } else {
14.  
    res = a / b
15.  
    }
16.  
    return
17.  
    }
18.  
     
19.  
    func main() {
20.  
    res := div(10, 0)
21.  
    fmt.Println(res) // -1
22.  
    }

panic异常会沿着调用堆栈向外传递, 所以也可以在外层捕获

1.  
   func div(a, b int) (res int) {
2.  
   if(b == 0){
3.  
   //err = errors.New("除数不能为0")
4.  
   panic("除数不能为0")
5.  
   }else{
6.  
   res = a / b
7.  
   }
8.  
   return
9.  
   }
10.  
    func main() {
11.  
    // panic异常会沿着调用堆栈向外传递, 所以也可以在外层捕获
12.  
    defer func() {
13.  
    if err := recover(); err != nil{
14.  
    fmt.Println(err) // 除数不能为0
15.  
    }
16.  
    }()
17.  
    div(10, 0)
18.  
    }

多个异常,只有第一个会被捕获

1.  
   func test1() {
2.  
   // 多个异常,只有第一个会被捕获
3.  
   defer func() {
4.  
   if err := recover(); err != nil{
5.  
   fmt.Println(err) // 异常A
6.  
   }
7.  
   }()
8.  
   panic("异常A") // 相当于return, 后面代码不会继续执行
9.  
   panic("异常B")
10.  
    }
11.  
    func main() {
12.  
    test1(10, 0)
13.  
    }

这篇好文章是转载于：学新通技术网