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

17 go语言（golang） - 错误处理

article 2024/12/4 17:39:19

错误处理

错误处理是编程中用于识别、响应和恢复程序运行时出现的错误和异常情况的过程。其目的是确保程序的鲁棒性（一个系统、模型或函数在面对错误输入、工作压力、意外情况或故意攻击时仍能保持稳定性和可靠性的能力），即使在出现错误的情况下也能正常运行或优雅地终止。

而Go语言中的错误处理是一种显式的、基于值的机制，与许多其他编程语言使用异常（exception）不同。Go通过返回值来处理错误，这使得代码更加清晰和可预测。

基本概念

`error`接口

Go内置了一个名为error的接口，用于表示错误。源码：

// The error built-in interface type is the conventional interface for
// representing an error condition, with the nil value representing no error.
// 内置的error接口类型是表示错误条件的常规接口，其nil值代表没有错误。
type error interface {
	Error() string
}

任何实现了这个接口的方法都可以作为一个错误对象。

自定义`error`

使用errors.New或fmt.Errorf()创建简单的文本描述性错误。

func Test1(t *testing.T) {
	err1 := errors.New("自定义错误1")
	fmt.Println(err1.Error())

	err2 := fmt.Errorf("自定义错误2")
	fmt.Println(err2)
}

输出

自定义错误1
自定义错误2

如果需要更复杂或结构化的信息，可以定义自己的类型并实现Error()方法。

type MyError struct {
	code int
	msg  string
}

func (m *MyError) Error() string {
	return fmt.Sprintf("code：%d,msg:%s", m.code, m.msg)
}

func Test2(t *testing.T) {
	myError := MyError{
		404,
		"自定义错误！",
	}
	fmt.Println(myError.Error())
	fmt.Println(myError)

}

输出

code：404,msg:自定义错误！
{404 自定义错误！}

函数返回值

在Go中，函数通常会返回两个值：结果和一个表示可能发生的错误。

func testDivide(a float64, b float64) (float64, error) {

	if b == 0 {
		return 0, fmt.Errorf("分母不能为0")
	} else {
		return a / b, nil
	}

}

检查和处理错误

调用函数时，需要检查第二个返回值是否为非nil，以判断是否发生了错误。

func Test3(t *testing.T) {
	var a float64 = 1
	var b float64

	divide, err := testDivide(a, b)
	if err != nil {
		fmt.Println(divide, err.Error())
	} else {
		fmt.Printf("结果为：%.2f\n", divide)
	}

}

输出

0 分母不能为0

错误包装与解包

Go1.13引入了对error wrapping的支持，通过使用 fmt.Errorf() 和 %w 格式化动词，可以将上下文信息附加到原始错误上。
使用 errors.Unwrap() 可以提取被包装过的一层的错误。
errors.Is函数用于检查一个错误是否与目标错误相同，或者是否是目标错误的一部分。

func Test4(t *testing.T) {
	err1 := errors.New("第一层错误")
	err2 := fmt.Errorf("第二层：%w", err1)

	fmt.Println(err1)
	fmt.Println(err2)

	// errors.Is函数用于检查一个错误是否与目标错误相同，或者是否是目标错误的一部分。

	// 注意参数顺序，检查第一个错误是不是第二个错误的子错误，或是否同一个错误
	bool1 := errors.Is(err1, err2) // 返回false
	fmt.Println(bool1)
	bool2 := errors.Is(err2, err1)
	fmt.Println(bool2)

	err3 := errors.Unwrap(err2)
	fmt.Println(err3)
}

输出：

第一层错误
第二层：第一层错误
false
true
第一层错误

错误类型断言与比较

使用类型断言来判断特定类型的自定义异常，并访问其内部字段。
（推荐）errors.As函数用于检查一个错误链中是否存在某个特定类型的错误，并且可以将该错误赋值给目标变量。它不仅适用于简单的类型断言，还能处理被包装过的复杂错误结构。

func Test5(t *testing.T) {
	myError := MyError{
		code: 400,
		msg:  "自定义错误",
	}
	var myErr error = &myError

	// 假设我们只知道这是个错误，但不知道具体的类型时，可以这样处理
	if err, ok := myErr.(*MyError); ok {
		fmt.Println(err.code, err.msg)
	}

	// 但是官方还是推荐我们使用as来判断具体的错误类型
	var targetErr *MyError
	if errors.As(myErr, &targetErr) {
		fmt.Println(targetErr.code, targetErr.msg)
	}

}

输出

400 自定义错误
400 自定义错误

断言只能判断是否那个类型，而error.As能查找是否该类型或子类型

func Test6(t *testing.T) {
	myError := MyError{
		code: 400,
		msg:  "自定义错误",
	}

	var myErr error = &myError
	// 再封装一层
	var myErrNew = fmt.Errorf("封装多一层：%w", myErr)

	// 假设我们只知道这是个错误，但不知道具体的类型时，可以这样处理
	if err, ok := myErrNew.(*MyError); ok {
		fmt.Println("1:", err.code, err.msg)
	}

	// 但是官方还是推荐我们使用as来判断具体的错误类型
	var targetErr *MyError
	if errors.As(myErrNew, &targetErr) {
		fmt.Println("2:", targetErr.code, targetErr.msg)
	}

}

输出

2: 400 自定义错误

panic和recover

panic

panic是Go语言中的一种内建机制，用于表示程序遇到了无法恢复的严重错误，导致程序的正常执行流程被中断。它类似于其他编程语言中的异常，但在Go中主要用于不可恢复的错误情况。虽然不推荐在正常业务逻辑中使用 panic，但在一些无法恢复或者必须立即停止程序执行情况下可以考虑，比如数组越界等。

关键特点

立即停止控制流：
- 当panic被调用时，程序会立即停止当前函数的执行，并开始运行任何已注册的defer函数。
向上传播：
- panic会沿着调用栈向上传播，逐层退出每个调用函数，并在每个退出点运行相应的defer语句。
终止程序：
- 如果没有捕获到并处理这个panic（即没有使用recover），最终会导致整个程序崩溃并打印出堆栈跟踪信息。

使用场景

通常用于那些不应该发生、且无法继续安全运行下去的问题，例如数组越界、空指针解引用等。
不建议在普通业务逻辑中使用，而是保留给真正需要立即停止执行的问题。

func Test1(t *testing.T) {
	defer fmt.Println("执行defer")

	fmt.Println("程序正常执行")

	panic("遇到错误！")

	fmt.Println("程序继续执行")

}

输出

=== RUN   Test1
程序正常执行
执行defer
--- FAIL: Test1 (0.00s)
panic: 遇到错误！ [recovered]
	panic: 遇到错误！

goroutine 6 [running]:
testing.tRunner.func1.2({0xa25ade0, 0xa284890})
	...
	...
	...

recover

recover是Go语言中用于处理panic的一种机制。它允许程序在发生panic后恢复执行，从而避免程序崩溃。通常与defer一起使用，以确保即使在函数发生恐慌时也能执行一些清理操作。

基本用法

捕获panic(恐慌)：当一个函数调用了 panic() 时，程序会立即停止当前函数的执行，并开始沿着调用栈向上传播，直到遇到一个能够处理该panic的地方。如果在传播过程中遇到了一个包含 recover() 的延迟（deferred）函数调用，那么可以通过 recover() 捕获这个恐慌。
返回值：如果成功捕获到一个正在传播中的恐慌，recover() 会返回传递给该 panic() 调用的值；如果没有处于panic状态，则返回 nil。

使用场景

防止程序崩溃：通过捕获和处理不可预见或致命错误，使得程序能够继续运行或进行适当降级。
清理资源：确保无论是否出现错误，都能正确释放资源（如文件句柄、网络连接等）。

func Test2(t *testing.T) {

	defer func() {
		a := recover()
		if a != nil {
			fmt.Println("recover捕获到panic：", a)
		} else {
			fmt.Println("recover没有捕获到panic")
		}
	}()

	fmt.Println("程序正常执行")

	panic("遇到错误！")

	fmt.Println("程序继续执行")

}

输出：

程序正常执行
recover捕获到panic： 遇到错误！

和throw相似

学过其他语言特别是java的同学应该发现，这与Java中的throw关键字非常相似。

尽管panic和throw在概念上相似，但它们在各自的语言中有着不同的使用习惯和语义。在Go中，panic通常用于处理真正的异常情况，比如程序的内部错误，而错误处理则通过返回error类型来完成。在Java中，throw关键字则用于更广泛的场景，包括业务逻辑中预期的异常情况。

主动抛出异常：在Go中使用panic和在Java中使用throw都可以主动抛出一个异常或错误条件。
改变程序控制流：两者都会导致程序的正常控制流被改变。在Go中，panic会立即停止当前函数的执行，并开始执行defer语句，然后向上返回，直到被recover捕获或者程序终止。而在Java中，如果没有在该方法内部捕获，则需要由上层调用者负责处理，否则可能会导致程序崩溃。
异常传播：在两个语言中，如果抛出的异常没有被立即捕获，它会继续向上传播到调用栈中的更高层，直到被捕获或者导致程序终止。
用于不可恢复的错误：panic和throw都用于表示那些不应该被忽略的严重错误，它们通常用于指示程序遇到了不可恢复的状态。
停止执行后续代码：在panic或throw之后的代码将不会被执行，直到异常被处理。
堆栈跟踪：当panic发生时，Go会打印出堆栈跟踪信息，类似于Java中throw异常时的行为，这有助于开发者定位错误发生的位置。