头图

golang中的错误处理

头像
liuyuede
    15
    发布于
    上海
     

    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

    4、错误值判断

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

    var ErrCourseware = errors.New("courseware")

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

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

    if err != nil {
    if errors.Is(err, ErrCourseware) {
        // ...
    } else {
        // ...
    }
}
    go错误
    本作品系原创，采用《署名-非商业性使用-禁止演绎 4.0 国际》许可协议
    avatar
    15 声望
    0 粉丝
    0 条评论
    得票最新
    推荐阅读
    一文搞懂秒杀系统，欢迎参与开源，提交PR，提高竞争力。早日上岸，升职加薪。
    前言秒杀和高并发是面试的高频考点，也是我们做电商项目必知必会的场景。欢迎大家参与我们的开源项目，提交PR，提高竞争力。早日上岸，升职加薪。知识点详解秒杀系统架构图秒杀流程图秒杀系统设计这篇文章一万多...

    王中阳Go赞 34阅读 2.6k评论 1

    封面图
    前端如何入门 Go 语言
    类比法是一种学习方法，它是通过将新知识与已知知识进行比较，从而加深对新知识的理解。在学习 Go 语言的过程中，我发现，通过类比已有的前端知识，可以更好地理解 Go 语言的特性。

    robin赞 23阅读 3.3k评论 6

    封面图
    Golang 中 []byte 与 string 转换
    string 类型和 []byte 类型是我们编程时最常使用到的数据结构。本文将探讨两者之间的转换方式，通过分析它们之间的内在联系来拨开迷雾。

    机器铃砍菜刀赞 24阅读 58.2k评论 2

    年度最佳【golang】map详解
    这篇文章主要讲 map 的赋值、删除、查询、扩容的具体执行过程，仍然是从底层的角度展开。结合源码，看完本文一定会彻底明白 map 底层原理。

    去去1002赞 16阅读 11.6k评论 2

    年度最佳【golang】GMP调度详解
    Golang最大的特色可以说是协程(goroutine)了, 协程让本来很复杂的异步编程变得简单, 让程序员不再需要面对回调地狱, 虽然现在引入了协程的语言越来越多, 但go中的协程仍然是实现的是最彻底的. 这篇文章将通过分析...

    去去1002赞 15阅读 11.9k评论 4

    万字详解，吃透 MongoDB！
    MongoDB 是一个基于 分布式文件存储 的开源 NoSQL 数据库系统，由 C++ 编写的。MongoDB 提供了 面向文档 的存储方式，操作起来比较简单和容易，支持“无模式”的数据建模，可以存储比较复杂的数据类型，是一款非常...

    JavaGuide赞 8阅读 1.7k

    封面图
    数据结构与算法：二分查找
    一、常见数据结构简单数据结构（必须理解和掌握）有序数据结构：栈、队列、链表。有序数据结构省空间（储存空间小）无序数据结构：集合、字典、散列表，无序数据结构省时间（读取时间快）复杂数据结构树、 堆图二...

    白鲸鱼赞 9阅读 5.3k

    avatar
    15 声望
    0 粉丝
    宣传栏