Go语言入门之错误处理

Go语言入门之错误处理

错误处理是开发中必不可少的一个部分，go中的错误一般有两种，一种为error，一种为panic

go语言通常返回一个错误值，然后检查错误值是否为nil，以此判断函数是否执行

1.Error

Go使用error接口来表示一个错误，任何实现此接口的类型都能当做一个错误。

（1）定义

// error 接口的定义
type error interface {
	Error() string
}

实例

type User struct {
	Name string
}

func genUser() (*User, error) {
	return nil, errors.New("user == nil")
}
func main() {
	if u, err := genUser(); err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(u.Name)
	}
}

使用经验

• error 应该是函数的最后一个返回值。
• 当 error 不为 nil 时，不应该对其他返回值有所期待。
• 只需在error最后出现的位置打印错误即可。

（2）使用

errors.New

func pay(money float64) error {
	if money < 10 {
		return errors.New("余额不足")
	}
	return nil
}

errors.Is

判断错误是否是某一个特定错误

var MoneyNotEnough = errors.New("余额不足")

func pay(money float64) error {
	if money < 10 {
		return errors.New("余额不足")
	}
	return nil
}

func main() {
	err := pay(5)
	if errors.Is(err, MoneyNotEnough) {
		fmt.Println("两个错误一致")
	} else {
        // 最后会输出这里
		fmt.Println("两个错误不一致")
	}
}

原因： 因为errors.New返回的是一个指针，每次New得到的地址都不同，这种设计可以防止如果两个错误是不同的错误，但是其中的字符串相同，errors.Is不会判断其是一种错误（可能面试会问）

fmt.Errorf

func pay(money float64) error {
	if money < 10 {
		return fmt.Errorf("余额不足:%f", money)
	}
	return nil
}

errors.As

提取指定类型的错误，判断包装的 error 链中，某一个 error 的类型是否与 target 相同，并提取第一个符合目标类型的错误的值，将其赋值给 target。

// errors.As()用于将error转换为具体的error类型
type MyError struct {
	Msg string
}

func (e *MyError) Error() string {
	return e.Msg
}

var MoneyNotEnough = &MyError{Msg: "余额不足"}

func pay(money float64) error {
	if money < 10 {
		return MoneyNotEnough
	}
	return nil
}

func main() {
	err := pay(5)
	var myError *MyError
	if errors.As(err, &myError) {
		fmt.Println("转换成功")
		fmt.Println(myError.Error())
	} else {
		fmt.Println("不是此error类型")
	}
}

fmt.Errorf()：创建一个新的错误。这个函数接受一个格式化字符串和一些参数，返回一个新的错误

// fmt.Errorf()可以将一个错误进行封装，封装后的错误和之前的相等
func main() {
	originalErr := errors.New("原始错误")
    //%w 嵌套生成一个新的错误
	newError := fmt.Errorf("error: %w", originalErr)
	if errors.Is(newError, originalErr) {
		fmt.Println("这两个错误相等")
	}
	//用于将一个错误对象展开，得到下一层错误对象
	originalErr1 := errors.Unwrap(newError)
	if errors.Is(originalErr, originalErr1) {
		fmt.Println("这两个错误相等")
	}
}

errors.Join

// errors.Join可以进行多个错误的封装，这是go1.20版本的新特性
func main() {
	err1 := errors.New("err1")
	err2 := errors.New("err2")
	err := errors.Join(err1, err2)
	if errors.Is(err, err1) {
		fmt.Println("err is err1")
	}
	if errors.Is(err, err2) {
		fmt.Println("err is err2")
	}
}

2.Panic

panic会导致程序直接退出。一般只有遇到不可恢复的错误才使用panic

（1）panic报错逻辑

当发生panic时，panic 函数会向上传播到调用它的 goroutine

如果 panic 函数没有被捕获，则会一直向上传播

直到遇到 defer 语句中调用的 recover() 函数

如果找不到recover调用，程序将打印panic的原因并退出

（2）代码实例

func main() {
	err := pay(5)
    // defer 延迟调用，在return结束前运行
	defer func() {
        // panic会被捕获
		if err := recover(); err != nil {
			log.Printf("panic:%+v \n", err)
		}
	}()
	if err != nil {
        // panic会打印详细的堆栈信息，便于定位错误
		panic("余额不足")
	}
}

也可以使用匿名函数处理

func main() {
    // 使用匿名函数 将需要保护的代码 控制在一定范围
	func() {
		err := pay(5)
		defer func() {
			if err := recover(); err != nil {
				log.Printf("panic:%+v \n", err)
			}
		}()
		if err != nil {
			panic("余额不足")
		}
	}()
	fmt.Println("发生panic后 这里的代码依旧会执行")
}

（3）recover()

• 用于捕获panic并恢复程序的执行
• 该函数可以接收一个参数，该参数将存储panic的原因
• 该函数只能在defer函数中才可以生效，处理panic

（4）注意事项

• 1.panic报错时recover并不能跨协程捕获，即本协程中的panic不能在其他协程中用recover捕获到
• 2.如果panic发生在defer函数中则不能用此内recover捕获，因为语句已被中断
• 3.如果recover在defer函数内的一个函数内，也会捕获失败
• 4.recover捕获如果有多个panic只会捕获最后一个
• 5.recover只在defer函数内才可以捕获panic

（5）常见场景

• 1.运行时错误：例如数组越界，字符串越界，空指针引用，除数为0等等
• 2.接口相关：接口未实现方法
• 3.channel相关：向关闭的通道内发送数据，关闭为nil的通道，关闭已经关闭的通道
• 4.map：给空map赋值，即给nil map写数据，并发读写相同map
• 4.死锁，所有线程睡眠
• 5.递归调用导致栈溢出或者死循环
• 6.无效类型转换，即类型断言失败
• 7.显示调用某些panic函数表示不可恢复场景