爱吃肉夹馍
golang通常有三种错误处理方式：错误哨兵（sentinel error）、错误类型断言和记录错误调用栈。错误哨兵指的是用特定值的变量作为错误处理分支的判定条件。错误类型用于路由错误处理逻辑，和错误哨兵有异曲同工的作用，由类型系统来提供错误种类的唯一性。错误黑盒指的是不过分关心错误类型，将错误返回给上层；当需要采取行动时，要针对错误的行为进行断言，而非错误类型。
本教程操作环境：windows7系统、go 1.18版本、dell g3电脑。
golang没有提供try-catch类似的错误处理机制，在设计层面采用了c语言风格的错误处理，通过函数返回值返回出错的错误信息，具体样例如下：
func returnerror() (string, error) {
return "", fmt.errorf("test error")
}
func main() {
val, err := returnerror()
if err != nil {
panic(err)
}
fmt.println(val)
}上面的例子是一个基本的错误处理样例，生产环境中执行的调用栈往往非常复杂，返回的error也各式各样，常常需要根据返回的错误信息确定具体的错误处理逻辑。
golang通常有如下的三种错误处理方式，错误哨兵(sentinel error)、错误类型断言(error type asseration)和记录错误调用栈。
错误哨兵(sentinel error)
哨兵指的是用特定值的变量作为错误处理分支的判定条件，常见的应用场景有gorm中的gorm.recordnotfounded和redis库里的redis.nil。
golang里可以对同类型变量进行比较，接口变量则比较接口指向的的指针的地址。因此，当且仅当error类型的变量指向同一地址时，此两种变量相等，否则都为不相等。
var errtest = errors.new("test error")
err := dosomething()
if err == errtest{
// todo: do with error
}使用哨兵存在如下几个问题存在两个问题：
1、代码结构不灵活，分支处理只能使用==或者!=进行判定，长此以往，容易写出常意大利面条式的代码。
var errtest1 = errors.new("errtest1")
var errtest2 = errors.new("errtest1")
var errtest3 = errors.new("errtest1")
……
var errtestn = errors.new("errtestn")
……
if err == errtest1{
……
} else if err == errtest2{
……
}else if err == errtest3{
……
}
……
else err == errtestn{
……
}2、哨兵变量值不能被修改，否则会导致逻辑错误，上述golang写法的error哨兵可以被改变，可以通过如下方式解决：
type error string
func (e error) error() string { return string(e) }3、哨兵变量会导致极强的耦合性，接口新增error的吐出就会造成使用者相应修改代码新增的处理错误问题。
相比较上面的方案，错误哨兵还有一种更为优雅的方案，依赖于接口而非变量：
var errtest1 = errors.new("errtest1")
func iserrtest1(err error) bool{
return err == errtest1
}错误类型
错误类型来路由错误处理逻辑，和错误哨兵有异曲同工的作用，由类型系统来提供错误种类的唯一性，使用方法如下：
type testerror {
}
func(err *testerror) error() string{
return "test error"
}
if err, ok := err.(testerror); ok {
//todo 错误分支处理
}
err := something()
switch err := err.(type) {
case nil:
// call succeeded, nothing to do
case *testerror:
fmt.println("error occurred on line:", err.line)
default:
// unknown error
}相比较于哨兵，错误类型的不变性更好，且可以使用switch来提供优雅的路由策略。但是这使得使用方依旧无法避免对于包的过重依赖。
使用接口抛出更复杂，多样的错误，依旧需要改变调用方的代码。
错误黑盒（依赖错误接口）
错误黑盒指的是不过分关心错误类型，将错误返回给上层。当需要采取行动时，要针对错误的行为进行断言，而非错误类型。
func fn() error{
x, err := foo()
if err != nil {
return err
}
}
func main(){
err := fn()
if istemporary(err){
fmt.println("temporary error")
}
}
type temporary interface {
temporary() bool
}
// istemporary returns true if err is temporary.
func istemporary(err error) bool {
te, ok := err.(temporary)
return ok && te.temporary()
}通过这样的方式，1.直接就解耦了接口间的依赖，2. 错误处理路由和错误类型无关，而与具体行为有关，避免了膨胀的错误类型。
总结
错误哨兵和错误类型避免不了依赖过重的问题，只有错误黑盒能够将问题从确定错误类型（变量）的处理逻辑变为确定错误行为。因此推荐使用第三种方式来处理错误。
这里必要要加一句，黑盒处理，返回错误并不意味着对错误的存在不理会或者是直接忽略，而是需要在合适的地方优雅得处理。在这个过程中，可以通过errors的wrap，zap打log等方式，在错误逐层返回的过程中记录调用链路的上下文信息。
func authenticate() error{
return fmt.errorf("authenticate")
}
func authenticaterequest() error {
err := authenticate()
// or logger.info("authenticate fail %v", err)
if err != nil {
return errors.wrap(err, "authenticaterequest")
}
return nil
}
func main(){
err := authenticaterequest()
fmt.printf("% v\n", err)
fmt.println("##########")
fmt.printf("%v\n", errors.cause(err))
}
// 打印信息
authenticate
authenticaterequest
main.authenticaterequest
/users/hekangle/mypersonproject/go-pattern/main.go:17
main.main
/users/hekangle/mypersonproject/go-pattern/main.go:23
runtime.main
/usr/local/cellar/go@1.13/1.13.12/libexec/src/runtime/proc.go:203
runtime.goexit
/usr/local/cellar/go@1.13/1.13.12/libexec/src/runtime/asm_amd64.s:1357
##########
authenticate【相关推荐：go视频教程、编程教学】
以上就是golang怎么进行错误处理的详细内容，更多请关注其它相关文章！
