首页 > 其他分享 >golang中的错误处理

golang中的错误处理

时间：2023-04-11 09:37:16浏览次数：53  
标签：err 错误 nil fmt golang func 错误处理 string

0.1、索引

https://waterflow.link/articles/1666716727236

1、panic

当我们执行panic的时候会结束下面的流程：

package main

import "fmt"

func main() {
	fmt.Println("hello")
	panic("stop")
	fmt.Println("world")
}

go run 9.go 
hello
panic: stop

但是panic也是可以捕获的，我们可以使用defer和recover实现：

package main

import "fmt"

func main() {

	defer func() {
		if r := recover(); r != nil {
			fmt.Println("recover: ", r)
		}
	}()

	fmt.Println("hello")
	panic("stop")
	fmt.Println("world")
}

go run 9.go
hello
recover:  stop

那什么时候适合panic呢？在 Go 中，panic 用于表示真正的异常，例如程序错误。我们经常会在一些内置包里面看到panic的身影。

比如strings.Repeat重复返回一个由字符串 s 的计数副本组成的新字符串：

func Repeat(s string, count int) string {
	if count == 0 {
		return ""
	}

	// 
	if count < 0 {
		panic("strings: negative Repeat count")
	} else if len(s)*count/count != len(s) {
		panic("strings: Repeat count causes overflow")
	}

	...
}

我们可以看到当重复的次数小于0或者重复count次之后s的长度溢出，程序会直接panic，而不是返回错误。这时因为strings包限制了error的使用，所以在程序错误时会直接panic。

还有一个例子是关于正则表达式的例子：

package main

import (
	"fmt"
	"regexp"
)

func main() {
	pattern := "a[a-z]b*" // 1
	compile, err := regexp.Compile(pattern) // 2
	if err != nil { // 2
		fmt.Println("compile err: ", err)
		return
	}
  // 3
	allString := compile.FindAllString("acbcdadb", 3)
	fmt.Println(allString)

}
  1. 编写一个正则表达式
  2. 调用Compile，解析正则表达式，如果成功，返回用于匹配文本的 Regexp 对象。否则返回错误
  3. 利用正则，在输入的字符串中，获取所有的匹配字符

可以看到如果上面正则解析失败是可以继续往下执行的，但是regexp包中还有另外一个方法MustCompile：

func MustCompile(str string) *Regexp {
	regexp, err := Compile(str)
	if err != nil {
		panic(`regexp: Compile(` + quote(str) + `): ` + err.Error())
	}
	return regexp
}

这个方法说明正则的解析是强依赖的，如果解析错误，直接panic结束程序。用户可以根据实际情况选择。

但是实际开发中我们还是要谨慎使用panic，因为它会使程序结束运行（除非我们调用defer recover）

2、包装错误

错误包装是将错误包装或者打包在一个包装容器中，这样的话我们就可以追溯到源错误。错误包装的主要作用就是：

  1. 为错误添加上下文
  2. 将错误标记为特定类型的错误

我们可以看一个访问数据库的例子：

package main

import (
	"fmt"
	"github.com/pkg/errors"
)

type Courseware struct {
	Id int64
	Code string
	Name string
}

func getCourseware(id int64) (*Courseware, error) {
	courseware, err := getFromDB(id)
	if err != nil {
		return nil, errors.Wrap(err, "六月的想访问这个课件") // 2
	}
	return courseware, nil
}

func getFromDB(id int64) (*Courseware, error) {
	return nil, errors.New("permission denied") // 1
}

func main() {
	_, err := getCourseware(11)
	if err != nil {
		fmt.Println(err)
	}
}
  1. 访问数据库时我们返回了原始的错误信息
  2. 到上层我们添加了一些自定义的上下文信息
go run 9.go
六月的想访问这个课件: permission denied

当然我们也可以将错误包装成我们自定义类型的错误，我们稍微修改下上面的例子：

package main

import (
	"fmt"
	"github.com/pkg/errors"
)

type Courseware struct {
	Id int64
	Code string
	Name string
}

// 1
type ForbiddenError struct {
	Err error
}

// 2
func (e *ForbiddenError) Error() string {
	return "Forbidden: " + e.Err.Error()
}

func getCourseware(id int64) (*Courseware, error) {
	courseware, err := getFromDB(id)
	if err != nil {
		return nil, &ForbiddenError{err} // 4
	}
	return courseware, nil
}

func getFromDB(id int64) (*Courseware, error) {
	return nil, errors.New("permission denied") // 3
}

func main() {
	_, err := getCourseware(11)
	if err != nil {
		fmt.Println(err)
	}
}
  1. 首先我们自定义了ForbiddenError的错误类型
  2. 我们实现了error接口
  3. 访问数据库抛出原始错误
  4. 上层返回ForbiddenError类型的错误
go run 9.go
Forbidden: permission denied

当然我们也可以不用创建自定义错误的类型，去包装错误添加上下文：

package main

import (
	"fmt"
	"github.com/pkg/errors"
)

type Courseware struct {
	Id int64
	Code string
	Name string
}


func getCourseware(id int64) (*Courseware, error) {
	courseware, err := getFromDB(id)
	if err != nil {
		return nil, fmt.Errorf("another wrap err: %w", err) // 1
	}
	return courseware, nil
}

func getFromDB(id int64) (*Courseware, error) {
	return nil, errors.New("permission denied")
}

func main() {
	_, err := getCourseware(11)
	if err != nil {
		fmt.Println(err)
	}
}
  1. 使用%w包装错误

使用这的好处是我们可以追溯到源错误，从而方便我们做一些特殊的处理。

还有一种方式是使用：

return nil, fmt.Errorf("another wrap err: %v", err)

%v的方式不会包装错误，所以无法追溯到源错误，但往往有时候我们会选择这种方式，而不用%w的方式。%w的方式虽然能包装源错误，但往往我们会通过源错误去做一些处理，假如源错误被修改，那包装这个源错误的相关错误都需要做响应变化。

3、错误类型判断

我们扩展一下上面查询课件的例子。现在我们有这样的判断，如果传进来的id不合法我们返回400错误，如果查询数据库报错我们返回500错误，我们可以像下面这样写：

package main

import (
	"fmt"
	"github.com/pkg/errors"
)

type Courseware struct {
	Id int64
	Code string
	Name string
}

type ForbiddenError struct {
	Err error
}

func (e *ForbiddenError) Error() string {
	return "Forbidden: " + e.Err.Error()
}

func getCourseware(id int64) (*Courseware, error) {
	if id <= 0 {
		return nil, fmt.Errorf("invalid id: %d", id)
	}
	courseware, err := getFromDB(id)
	if err != nil {
		return nil, &ForbiddenError{err}
	}
	return courseware, nil
}

func getFromDB(id int64) (*Courseware, error) {
	return nil, errors.New("permission denied")
}

func main() {
	_, err := getCourseware(500) // 我们可以修改这里的id看下打印的结构
	if err != nil {
		switch err := err.(type) {
		case *ForbiddenError:
			fmt.Println("500 err: ", err)
		default:
			fmt.Println("400 err: ", err)
		}
	}
}

go run 9.go
500 err:  Forbidden: permission denied

这样看起来好像也没什么问题，现在我们稍微修改下代码，把上面ForbiddenError包装一下：

package main

import (
	"fmt"
	"github.com/pkg/errors"
)

type Courseware struct {
	Id int64
	Code string
	Name string
}

type ForbiddenError struct {
	Err error
}

func (e *ForbiddenError) Error() string {
	return "Forbidden: " + e.Err.Error()
}

func getCourseware(id int64) (*Courseware, error) {
	if id <= 0 {
		return nil, fmt.Errorf("invalid id: %d", id)
	}
	courseware, err := getFromDB(id)
	if err != nil {
		return nil, fmt.Errorf("wrap err: %w", &ForbiddenError{err}) // 这里包装了一层错误
	}
	return courseware, nil
}

func getFromDB(id int64) (*Courseware, error) {
	return nil, errors.New("permission denied")
}

func main() {
	_, err := getCourseware(500)
	if err != nil {
		switch err := err.(type) {
		case *ForbiddenError:
			fmt.Println("500 err: ", err)
		default:
			fmt.Println("400 err: ", err)
		}
	}
}

go run 9.go
400 err:  wrap err: Forbidden: permission denied

可以看到我们的Forbidden错误进到了400里面，这并不是我们想要的结果。之所以会这样，是因为在ForbiddenError的外面又包装了一层Error错误，使用类型断言的时候判断出来的是Error错误，所以进到了400分支。

这里我们可以使用errors.As方法，它会递归调用Unwrap方法，找到错误链中第一个与target匹配的方法：

package main

import (
	"fmt"
	"github.com/pkg/errors"
)

type Courseware struct {
	Id int64
	Code string
	Name string
}

type ForbiddenError struct {
	Err error
}

func (e *ForbiddenError) Error() string {
	return "Forbidden: " + e.Err.Error()
}

func getCourseware(id int64) (*Courseware, error) {
	if id <= 0 {
		return nil, fmt.Errorf("invalid id: %d", id)
	}
	courseware, err := getFromDB(id)
	if err != nil {
		return nil, fmt.Errorf("wrap err: %w", &ForbiddenError{err})
	}
	return courseware, nil
}

func getFromDB(id int64) (*Courseware, error) {
	return nil, errors.New("permission denied")
}

func main() {
	_, err := getCourseware(500)
	if err != nil {
		var f *ForbiddenError // 这里实现了*ForbiddenError接口，不然会panic
		if errors.As(err, &f) { // 找到匹配的错误
			fmt.Println("500 err: ", err)
		} else {
			fmt.Println("400 err: ", err)
		}
	}
}

go run 9.go
500 err:  wrap err: Forbidden: permission denied
SHELL 复制 全屏

4、错误值判断

在代码中或者mysql库或者io库中我们经常会看到这样的全局错误：

var ErrCourseware = errors.New("courseware")

这种错误我们称之为哨兵错误。一般数据库没查到ErrNoRows或者io读到了EOF错误，这些特定的错误可以帮助我们做一些特殊的处理。

一般我们会直接用==号判断错误值，但是就像上面的如果错误被包装哪我们就不好去判断了。好在errors包中提供了errors.Is方法，通过递归调用Unwrap判断错误链中是否与目标错误相匹配的错误值：

if err != nil {
    if errors.Is(err, ErrCourseware) {
        // ...
    } else {
        // ...
    }
}

标签：err,错误,nil,fmt,golang,func,错误处理,string
From： https://www.cnblogs.com/golandhome/p/17305087.html

相关文章

  • 如何用Golang处理每分钟100万个请求
    用Golang处理每分钟100万个请求转载请注明来源：https://janrs.com/9yaq面临的问题在我设计一个分析系统中，我们公司的目标是能够处理来自数百万个端点的大量POST请求。web网络处理程序将收到一个JSON文档，其中可能包含许多有效载荷的集合，需要写入AmazonS3，以便我们的地图还原......
  • [golang]使用logrus自定义日志模块
    简介logrus是一个第三方日志库，性能虽不如zap和zerolog，但方便易用灵活。logrus完全兼容标准的log库，还支持文本、JSON两种日志输出格式。特点相较于标准库，logrus有更细致的日志级别，从高到低分别是：trace>debug>info>warn>error>fatal>panic支持自定义日志格式，内置支......
  • ChatGPT垂直行业私有数据知识库功能-咨询接口采用流式响应输出-JS和Golang实现流式响
    近期开发私有数据知识库功能，想要实现和ChatGPT聊天效果类似的逐字流式输出展示效果。GPT3.5本身就有流式聊天补全接口，后端Golang对接后，也需要能流式输出。下面就介绍下前端JS后端Golang来实现这种输出效果 大部分介绍是使用EventStream来实现，我现在不使用EventStream也来实现......
  • Golang基础-- select的用法
    select是golang在语言层面提供的多路IO复用的机制，其可以检测多个channel是否ready三个题目示例来说明一下select的大概作用：题目一：声明两个channel，分别为chan1和chan2，依次启动两个协程，分别向两个channel中写入一个数据就进入睡眠。select语句两个case分别检测chan1和chan2是......
  • golang 中的 goto 用法和使用场景（转）
    转自：golang中的goto场景一：跳出多重循环packagemainimport"fmt"funcmain(){forx:=0;x<10;x++{fory:=0;y<10;y++{ify==2{//跳转到标签gotobreakHere}......
  • golang 编译碰到问题 Package python-2.7 was not found in the pkg-config search pa
    golang运行单测或者编译程序时提示需要配置PKG_CONFIG_PATH环境变量，原因是在程序里使用了go-python包，要求运行环境有python2.7，并设置PKG_CONFIG_PATH环境变量，解决方案如下：#pkg-config--cflags--python-2.7Packagepython-2.7wasnotfoundinthepkg-configsear......
  • Golang与Java全方位对比总结
    本文针对Golang与Java的基础语法、结构体函数、异常处理、并发编程及垃圾回收、资源消耗等各方面的差异进行对比总结，有不准确、不到位的地方还请大家不吝赐教。一、基础语法Golang:编码风格及可见域规则严格且简单；Java:来说层次接口清晰、规范，主要表现有以下这些。1、变量......
  • Golang基础--defer的用法
    defer语句用于延迟函数的调用，每次defer都会把一个函数压入栈中，函数返回前再把延迟的函数取出执行。三个示例：import"fmt"funcmain(){varinit=1deferfmt.Println(init)init=2}输出1。延迟函数fmt.Println(aInt)的参数在defer语句出现时就已经确......
  • Golang回调函数
    Golang回调函数实例二则定义回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于......
  • Golang反射获取变量类型和值
    Golang反射获取变量类型和值 1.什么是反射反射是程序在运行期间获取变量的类型和值、或者执行变量的方法的能力。Golang反射包中有两对非常重要的函数和类型，两个函数分别是：reflect.TypeOf能获取类型信息reflect.Type；reflect.ValueOf 能获取数据的运行时表示reflect.Val......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99