golang如何进行错误处理

这篇“golang如何进行错误处理”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“golang如何进行错误处理”文章吧。 Golang通常有三种错误处理方式：错误哨兵（Sentinel Error）、错误类型断言和记录错误调用栈。错误哨兵指的是用特定值的变量作为错误处理分支的判定条件。错误类型用于路由错误处理逻辑，和错误哨兵有异曲同工的作用，由类型系统来提供错误种类的唯一性。错误黑盒指的是不过分关心错误类型，将错误返回给上层；当需要采取行动时，要针对错误的行为进行断言，而非错误类型。golang没有提供try-catch类似的错误处理机制，在设计层面采用了C语言风格的错误处理，通过函数返回值返回出错的错误信息，具体样例如下：


funcReturnError()(string,error){
	return"",fmt.Errorf("TestError")
}

funcmain(){
	val,err:=ReturnError()
	iferr!=nil{
		panic(err)
	}
	fmt.Println(val)
}

上面的例子是一个基本的错误处理样例，生产环境中执行的调用栈往往非常复杂，返回的error也各式各样，常常需要根据返回的错误信息确定具体的错误处理逻辑。Golang通常有如下的三种错误处理方式，错误哨兵(Sentinel Error)、错误类型断言(Error Type Asseration)和记录错误调用栈。哨兵指的是用特定值的变量作为错误处理分支的判定条件，常见的应用场景有gorm中的gorm.RecordNotFounded和redis库里的redis.NIL。golang里可以对同类型变量进行比较，接口变量则比较接口指向的的指针的地址。因此，当且仅当error类型的变量指向同一地址时，此两种变量相等，否则都为不相等。


varErrTest=errors.New("TestError")

err:=doSomething()
iferr==ErrTest{
	//TODO:DoWithError
}

使用哨兵存在如下几个问题存在两个问题：1、代码结构不灵活，分支处理只能使用==或者!=进行判定，长此以往，容易写出常意大利面条式的代码。


varErrTest1=erro免费云主机域名rs.New("ErrTest1")
varErrTest2=errors.New("ErrTest1")
varErrTest3=errors.New("ErrTest1")
……
varErrTestN=errors.New("ErrTestN")
……
iferr==ErrTest1{
	……
}elseiferr==ErrTest2{
	……
}elseiferr==ErrTest3{
	……
}
……
elseerr==ErrTestN{
	……
}

2、哨兵变量值不能被修改，否则会导致逻辑错误，上述golang写法的error哨兵可以被改变，可以通过如下方式解决：


typeErrorstring

func(eError)Error()string{returnstring(e)}

3、哨兵变量会导致极强的耦合性，接口新增error的吐出就会造成使用者相应修改代码新增的处理错误问题。相比较上面的方案，错误哨兵还有一种更为优雅的方案，依赖于接口而非变量：


varErrTest1=errors.New("ErrTest1")

funcIsErrTest1(errerror)bool{
returnerr==ErrTest1
}

错误类型来路由错误处理逻辑，和错误哨兵有异曲同工的作用，由类型系统来提供错误种类的唯一性，使用方法如下：


typeTestError{
}
func(err*TestError)Error()string{
	return"TestError"
}
iferr,ok:=err.(TestError);ok{
	//TODO错误分支处理
}

err:=something()
switcherr:=err.(type){
casenil:
//callsucceeded,nothingtodo
case*TestError:
fmt.Println("erroroccurredonline:",err.Line)
default:
//unknownerror
}

相比较于哨兵，错误类型的不变性更好，且可以使用switch来提供优雅的路由策略。但是这使得使用方依旧无法避免对于包的过重依赖。使用接口抛出更复杂，多样的错误，依旧需要改变调用方的代码。错误黑盒指的是不过分关心错误类型，将错误返回给上层。当需要采取行动时，要针对错误的行为进行断言，而非错误类型。


funcfn()error{
	x,err:=Foo()
	iferr!=nil{
		returnerr
	}
}

funcmain(){
	err:=fn()
	ifIsTemporary(err){
		fmt.Println("TemporaryError")
	}
}

typetemporaryinterface{
Temporary()bool
}

//IsTemporaryreturnstrueiferristemporary.
funcIsTemporary(errerror)bool{
te,ok:=err.(temporary)
returnok&&te.Temporary()
}

通过这样的方式，1.直接就解耦了接口间的依赖，2. 错误处理路由和错误类型无关，而与具体行为有关，避免了膨胀的错误类型。错误哨兵和错误类型避免不了依赖过重的问题，只有错误黑盒能够将问题从确定错误类型（变量）的处理逻辑变为确定错误行为。因此推荐使用第三种方式来处理错误。这里必要要加一句，黑盒处理，返回错误并不意味着对错误的存在不理会或者是直接忽略，而是需要在合适的地方优雅得处理。在这个过程中，可以通过errors的Wrap，Zap打log等方式，在错误逐层返回的过程中记录调用链路的上下文信息。


funcauthenticate()error{
	returnfmt.Errorf("authenticate")
}

funcAuthenticateRequest()error{
	err:=authenticate()
	//ORlogger.Info("authenticatefail%v",err)
	iferr!=nil{
		returnerrors.Wrap(err,"AuthenticateRequest")
	}
	returnnil
}

funcmain(){
	err:=AuthenticateRequest()
	fmt.Printf("%+vn",err)
	fmt.Println("##########")
	fmt.Printf("%vn",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

以上就是关于“golang如何进行错误处理”这篇文章的内容，相信大家都有了一定的了解，希望小编分享的内容对大家有帮助，若想了解更多相关的知识内容，请关注百云主机行业资讯频道。

相关推荐: Node.js怎么使用流实现边读边写功能

这篇“Node.js怎么使用流实现边读边写功能”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，免费云主机域名内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“Node.js怎么使用流实现边读边写功…