程序运行过程中不可避免的发生各种错误，要想让自己的程序保持较高的健壮性，那么异常，错误处理是需要考虑周全的，每个编程语言提供了一套自己的异常错误处理机制，在Go中，你知道了吗？接下来我们一起看看Go的异常错误机制。

Go错误处理，函数多返回值是前提

首先我们得明确一点，Go是支持多返回值的，如下，sum函数进行两个int型数据的求和处理，函数结果返回最终的和（z）以及入参（x，y）,既然支持多返回值，同理，我们能否把错误信息返回呢？当然是可以的

  1. func sum (x,y int) (int,int,int){
  2.     z := x+y
  3.     return z,x,y
  4. }

Go内置的错误类型

在Go中内置了一个error接口用来用来处理错误

  1. // The error built-in interface type is the conventional interface for
  2. // representing an error condition, with the nil value representing no error.
  3. //翻译下来就是：
  4. //错误的内置接口类型是 error,没有错误用 nil 表示
  5. type error interface {  
  6.     Error() string
  7. }

我们来看Go内置的一个关于error接口的简单实现

  1. func New(text string) error {        
  2.     return &errorString{text}
  3. }
  4. // errorString is a trivial implementation of error.
  5. 翻译
  6. // 把error转换成String是错误的简单实现
  7. type errorString struct {        
  8.     s string
  9. }
  10. func (e *errorString) Error() string { 
  11.     return e.s
  12. }

我们可以看到errorString结构体实现了 Error()string 接口，通过New()方法返回一个errorString指针类型的对象。
看到这里不知道大家想到没，Go对错误的处理就是显示的通过方法返回值告诉你需要对错误进行判断和处理。也就是错误对你是可见的，这也需要开发人员在方法中尽可能的考虑到各种发生的错误，并返回给方法调用者。

Go内置的异常捕获

我们知道程序在运行时会发生各种各样的运行时错误，比如数组下标越界异常，除数为0的异常等等，而这些异常如果不被处理会导致go程序的崩溃，那么如何捕获这些运行时异常转化为错误返回给上层调用链，就让我一起看看这几个关键字：panic, defer recover，此处我们不讨论原理。
go内置了这几个关键字，下面是这几个关键字的含义：
1. panic 恐慌
2. defer 推迟，延缓
3. recover 恢复
我们把运行时发生异常称为发生了一个恐慌，我们也可以手动抛出一个恐慌，如下

  1. func TestPanic(){
  2.     panic("发生恐慌了")
  3. }
  4. //截取一部分结果,我们看到程序终止了，打印了堆栈信息
  5. anic: 发生恐慌了 [recovered]
  6.     panic: 发生恐慌了
  7. goroutine 19 [running]:
  8. testing.tRunner.func1(0xc0000b6100)
  9.     D:/sdk/go12/src/testing/testing.go:830 +0x399
  10. panic(0x521da0, 0x57bb10)
  11.     D:/sdk/go12/src/runtime/panic.go:522 +0x1c3
  12. gome_tools/basic.TestPanic(...)
  13.     D:/gome_space/gome_tools/basic/array_slice.go:101

恐慌发生了怎么处理呢，这时需要defer和recover一起协作，defer什么意思呢，是表示这个方法最后执行的一段代码，无论这个方法发生错误，异常等，defer里面的里代码一定会被执行,而我们可以在defer中通过recover关键字恢复我们的恐慌，将之处理，转化为一个错误并打印，如下代码：

  1. func TestDeferAndRecover(){
  2.     defer func(){
  3.         if err:=recover(); err != nil{
  4.             fmt.Println("异常信息为:",err)
  5.         }
  6.     }()    
  7.     panic("发生恐慌了")
  8. }
  9. //结果
  10. 异常信息为: 发生恐慌了

Go异常错误处理示例

接下来我们看一个除法函数，函数中，如果被除数为0，则除法运算是失败的

  1. func division(x,y int) （int,error）{
  2.     //如果除数为0，则返回一个错误信息给上游
  3.     if y == 0{
  4.         return 0,errors.New("y is not zero")
  5.     }   
  6.     z := x / y
  7.     return z ,nil
  8. }
  9. result, err := division(1,0)
  10. if err != nil {
  11.     //处理错误逻辑
  12. }
  13. //处理正常逻辑

如上，division函数里面判断y等于0时，给调用者返回一个错误信息，调用者通过两个变量来接受division的返回值，判断 err是否为空做出不同的错误处理逻辑
有些错误，我们知道是不可能发生的，那么如何忽略这类错误呢？
还是上面的 division(x,y)(z,error) 函数,假设我们入参传（4，2）进去，这时我们是清楚的知道不可能发生错误,我们可以按如下处理,通过下划线 _ 忽略这个返回值。

  1. //通过_忽略第二个返回值
  2. result, _ := division(1,0)
  3. //打印结果
  4. fmt.Println(result)

只要是人，总有考虑不周的时候，总有想不到的时候，
还是division(x,y)(z,error)函数，假设小明忘记了或者没想到要判断除数为0的情况，写出来的代码如下：

  1. func division(x,y int) (int,error){
  2.     z := x / y
  3.     return z ,nil
  4. }

小红在调用上面的方法时写成了 result,_ := division(1,0)，很明显division方法是会发生错误的，错误信息如下，integer divide by zero ，被除数为0，我们知道程序出错了，并且整个程序终止了
tips: Go语言中，一旦某一个协程发生了panic而没有被捕获，那么导致整个go程序都会终止，确实有点坑，但确实如此（了解java的人都知道，在java中一个线程发生发生了异常，只要其主线程不曾终止，那么整个程序还是运行的） ，但go不是这样的，文章最后我会写一个例子，大家可以看看。
通过上面的tips，我们知道，我们不能让我们的方法发生panic，在不确保方法不会发生panic时一定要捕获，谨记。

  1. panic: runtime error: integer divide by zero [recovered]
  2.     panic: runtime error: integer divide by zero

发生panic时，如何捕获这个panic给上游返回一个error

  1. func division(x,y int) (result int,err error){
  2.     defer func(){
  3.         if e := recover(); e != nil{
  4.             err = e.(error)
  5.         }
  6.     }()
  7.     result = x / y
  8.     return result ,nil
  9. }

这段代码什么意思呢？当我们division(1,0)时，一定会报除0异常，division函数声明了返回值result（int型），err(error型)，当x / y发生异常时，在defer函数中，我们通过recover()函数来捕获发生的异常，如果不为空，将这个异常赋值给返回结果的变量 err,我们再来调用这个函数division(1,0)看看输出什么,如下，是不是将堆栈信息转化为了一段字符串描述。

  1. 0 runtime error: integer divide by zero

如何自定义自己的错误类型
我们知道go中关于错误定义了一个接口，如果想要自定义自己的错误类型，我们只需要实现这个接口就可以了,还是这个函数，我们为其定义一个除数为0的错误

  1. type DivideByZero struct{
  2.     //错误信息
  3.     e string
  4.     //入参信息（除数和被除数）
  5.     param string
  6. }
  7. //实现接口中的Error()string方法，组装错误信息为字符串
  8. func (e *DivideByZero) Error() string { 
  9.     buffer := bytes.Buffer{}
  10.     buffer.WriteString("错误信息：")
  11.     buffer.WriteString(divideByZero.e)
  12.     buffer.WriteString(",入参信息：")
  13.     buffer.WriteString(divideByZero.param)
  14.     return buffer.String()
  15. }
  16. func division(x,y int) （int,error）{
  17.     //如果除数为0，则返回一个错误信息给上游
  18.     if y == 0{
  19.         //这个时候我们返回如下错误
  20.         return 0, &DivideByZero{
  21.             e:"除数不能0",
  22.             param:strings.Join([]string{strconv.Itoa(x),strconv.Itoa(y)},","),
  23.         }
  24.     }   
  25.     z := x / y
  26.     return z ,nil
  27. }
  28. //最终结果
  29. 0 错误信息：除数不能为0,入参信息：1,0

最后补一下上面说的示例

上文提到，go中一旦某一个协程发生了panic而没被recover，那么整个go程序会终止，而Java中，某一线程发生了异常，即便没被catche,那么只是这个线程终止了，Java程序是不会终止的，只有主线程完成Java程序才会结束，看下面两段代码

  1. public static void main(String []args){
  2.     new Thread(new Runnable() {    
  3.         @Override    
  4.         public void run() {
  5.             throw new RuntimeException("抛出异常了");   
  6.         }
  7.     }).start();
  8.     try {    
  9.         Thread.sleep(10 * 1000)；
  10.     }catch (InterruptedException e) {
  11.     }
  12. }
  1. func main(){
  2.     go func() {
  3.         panic("发生恐慌了")
  4.     }()
  5.     time.Sleep(10 * time.Second)
  6. }

上面两端代码含义都是一样的，启动后各开一个线程和协程，在线程和协程内分别主动抛出异常，但结果不一样，java的主线程会休眠10秒钟后结束，而go主协程会立即结束。

欢迎大家关注微信公众号：“技术人技术事”，更多精彩期待你的到来
GoLang公众号.jpg