Go的错误、异常处理机制

错误和异常的区别

• 错误指的是可能出现问题的地方出现了问题，比如打开一个文件时失败，这种情况在人们的意料之中 ；而异常指的是不应该出现问题的地方出现了问题，比如引用了空指针，这种情况在人们的意料之外。可见，错误是业务过程的一部分，而异常不是 。

• 错误和异常从Golang机制上讲，就是error和panic的区别。

• Golang错误和异常是的互相转换的：

  错误转异常，比如程序逻辑上尝试请求某个URL，最多尝试三次，尝试三次的过程中请求失败是错误，尝试完第三次还不成功的话，失败就被提升为异常了。

  异常转错误，比如panic触发的异常被recover恢复后，将返回值中error类型的变量进行赋值，以便上层函数继续走错误处理流程。

• Go语言中，一旦某一个协程发生了panic而没有被recover，那么会导致整个go程序都会终止

关于异常与错误设计原则

错误设计：

• 如果失败原因只有一个，则返回bool
• 如果失败原因超过一个，则返回error
• 如果没有失败原因，则不返回bool或error
• 如果重试几次可以避免失败，则不要立即返回bool或error

异常设计：

• 在程序开发阶段，坚持速错，让程序异常崩溃
• 在程序部署后，应恢复异常避免程序终止
• 对于不应该出现的分支，使用异常处理

Go内置error接口处理用来处理错误

// The error built-in interface type is the conventional interface for
// representing an error condition, with the nil value representing no error.
type error interface {
	Error() string
}

内置new实现接口的实现

// New returns an error that formats as the given text.
// Each call to New returns a distinct error value even if the text is identical.
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
}

Go内置异常处理函数

• Go内置函数panic和recover来触发和终止异常处理流程，同时引入关键字defer来延迟执行defer后面的函数。
• defer延迟函数总是在异常panic或者正常return前返回

  	func main(){
  	defer fmt.Println(123)
  	defer fmt.Println(456)
  	panic("panic")
  }
  /*
  output:
  456
  123
  panic: panic
  */
  

• panic是函数时，总是先执行；之后才会执行defer函数，最后返回panic

  	func main(){
  	defer fmt.Println(123)
  	defer fmt.Println(456)
  	panic(test())
  }
  func test()string{
  	fmt.Println("akjfjk")
  	return "test"
  }
  /*
  output:
  akjfjk
  456
  123
  panic: test
  */
  

  可以在defer中通过recover关键字恢复我们的panic，将之处理后转化为一个错误并打印（异常转错误）

  func TestDeferAndRecover(){
  defer func(){
      if err:=recover(); err != nil{
          fmt.Println("err is:",err)
      }
  }()    
      panic("panic has happended")
  }
  /*
  output:
  err is: panic has happended
  */
  
  

Go异常错误处理案例

开始代码

func divi(x,y int) (int,error){
	if y == 0{
		return 0,errors.New("y can`t be zero")
	}
	z := x / y
		return z ,nil
}
/*
divi(1,0)
output:
0 y can`t be zero
*/

当没有考虑到y不可以为零时；可以使用recover来捕捉panic，defer来延迟执行；作为错误来返回(避免异常导致整个程序Down掉)

func divi(x,y int) (z int,err error){
	defer func() {
		if e := recover();e!=nil{
			err =e.(error)
		}
	}()
	z = x / y
	return z ,nil
}
/*
output:
0 runtime error: integer divide by zero
*/

自定义错误类型

首先需要实现error这个接口类

type DIYerror struct{
	e string
	param string
}

func (d *DIYerror)Error()string{
	obj:= bytes.Buffer{}
	obj.WriteString("err is:")
	obj.WriteString(d.e)
	obj.WriteString("param is:")
	obj.WriteString(d.param)
	return obj.String()
}

func divi(x,y int) (z int,err error){
	if y == 0 {
		return 0,&DIYerror{
			e: "y can`t be 0",
			param: strings.Join([]string{strconv.Itoa(x),strconv.Itoa(y)},","),
		}
	}
	z = x / y
	return z ,nil
}
/*
output；
0 err is:y can`t be 0param is:1,0
*/