当前位置：首页 > article >正文

【go从零单排】error错误处理及封装

article 2024/11/14 12:43:38

挪威特罗姆瑟夜景

🌈Don’t worry , just coding!
内耗与overthinking只会削弱你的精力，虚度你的光阴，每天迈出一小步，回头时发现已经走了很远。

📗概念

在 Go 语言中，error 是一个内置的接口类型，用于表示错误情况。Go 的错误处理机制与许多其他编程语言不同，它强调显式的错误处理，而不是使用异常机制。

💻代码

package main

//导入errors包和fmt包
import (
	"errors"
	"fmt"
)

// 函数f，输出一个int，输出一个int，一个error
// 函数接受一个整数 arg，如果 arg 等于 42，则返回一个错误；否则返回 arg + 3 和 nil（表示没有错误）
func f(arg int) (int, error) {
	if arg == 42 {
		//errors.New创建一个error的实例
		return -1, errors.New("can't work with 42")
	}

	return arg + 3, nil
}

// 定义了两个错误变量 ErrOutOfTea 和 ErrPower，用于表示特定的错误情况
var ErrOutOfTea = fmt.Errorf("no more tea available")
var ErrPower = fmt.Errorf("can't boil water")

func makeTea(arg int) error {
	if arg == 2 {
		return ErrOutOfTea
	} else if arg == 4 {
		// %w 用于包装 ErrPower 错误
		return fmt.Errorf("making tea: %w", ErrPower)
	}
	return nil
}

func main() {
	for _, i := range []int{7, 42} {
		//r, e := ...这是 Go 语言中的多重赋值语法。调用 f(i) 的结果会被同时赋值给两个变量
		//这个条件用于检查 e 是否为 nil。在 Go 中，nil 表示没有错误
		//if r, e := f(i); e != nil 这种写法将会很常见，在if语句中检查错误判断
		if r, e := f(i); e != nil {
			fmt.Println("f failed:", e) //e 不为 nil，则表示函数 f 在执行过程中发生了错误,抛出错误
		} else {
			fmt.Println("f worked:", r)
		}
	}
	//for 循环i=range 5
	for i := range 5 {
		if err := makeTea(i); err != nil {
			//判断error的各种特定类型
			if errors.Is(err, ErrOutOfTea) {
				fmt.Println("We should buy new tea!")
			} else if errors.Is(err, ErrPower) {
				fmt.Println("Now it is dark.")
			} else {
				fmt.Printf("unknown error: %s\n", err)
			}
			continue
		}

		fmt.Println("Tea is ready!")
	}
}
//输出$ go run errors.go
//f worked: 10
//f failed: can't work with 42
//Tea is ready!
//Tea is ready!
//We should buy new tea!
//Tea is ready!
//Now it is dark.

🔍几种创建error的方式

errors.New

import "errors"

err := errors.New("this is an error")

fmt.Errorf

import "fmt"

err := fmt.Errorf("an error occurred: %s", "details")

自定义错误类型

type MyError struct {
    Message string
    Code    int
}

func (e *MyError) Error() string {
    return fmt.Sprintf("Error %d: %s", e.Code, e.Message)
}

检查error

func doSomething() error {
    // 可能会发生错误的操作
    return errors.New("an error occurred")
}

func main() {
	//检查错误
    if err := doSomething(); err != nil {
        fmt.Println("Error:", err)
    }
}

包装error

Go 1.13 引入了错误包装的概念，可以使用 %w 占位符来创建一个新的error，并将原始error包含在其中。

func doSomething() error {
    return fmt.Errorf("failed to do something: %w", errors.New("original error"))
}

// 在调用处检查原始错误
if err := doSomething(); err != nil {
    if errors.Is(err, errors.New("original error")) {
        fmt.Println("Handled the original error")
    }
}

常用的error处理模式

if errors.Is(err, specificError) {
    // 处理特定错误
}

var myErr *MyError
if errors.As(err, &myErr) {
    // 处理自定义错误
}

go中的error接口

error只有一个方法 Error()，返回一个字符串，描述错误的原因

type error interface {
    Error() string
}

定制自己的error类参考

package main

//import errors包
import (
	"errors"
	"fmt"
)

// 自定义struct，建议命名为argError，后缀为Error
type argError struct {
	arg     int
	message string
}

// 定义Error方法，输入argError指针，返回一个Error() string ，符合error方法的要求
func (e *argError) Error() string {
	//d 表示一个整数，在这里是 e.arg，%s 表示一个字符串（在这里是 e.message）
	return fmt.Sprintf("%d - %s", e.arg, e.message)
}

// 定义f函数，输入int，输出一个int，一个error
func f(arg int) (int, error) {
	if arg == 42 {
		//返回-1和一个指向 argError 实例的指针
		return -1, &argError{arg, "can't work with it"}
	}
	return arg + 3, nil
}

func main() {

	_, err := f(42)
	//声明一个指向 argError 类型的指针变量 ae，初始值为 nil
	var ae *argError
	//errors.As 函数用于检查 err 是否是 argError 类型的错误。如果是，它会将 err 转换为 *argError 类型，并赋值给 ae。
	if errors.As(err, &ae) {
		fmt.Println(ae.arg)
		fmt.Println(ae.message)
	} else {
		fmt.Println("err doesn't match argError")
	}
}