Go错误处理
Go 错误处理
Go 语言通过内置的错误接口提供了非常简单的错误处理机制。
Go 语言的错误处理采用显式返回错误的方式，而非传统的异常处理机制。这种设计使代码逻辑更清晰，便于开发者在编译时或运行时明确处理错误。
Go 的错误处理主要围绕以下机制展开：
error 接口：标准的错误表示。显式返回值：通过函数的返回值返回错误。自定义错误：可以通过标准库或自定义的方式创建错误。panic 和 recover：处理不可恢复的严重错误。
error 接口Go 标准库定义了一个 error 接口，表示一个错误的抽象。
error 类型是一个接口类型，这是它的定义：
type error interface {
Error() string
}
实现 error 接口：任何实现了 Error() 方法的类型都可以作为错误。Error() 方法返回一个描述错误的字符串。
使用 errors 包创建错误我们可以在编码中通过实现 error 接口类型来生成错误信息。
创建一个简单错误：
实例
package main
import (
“errors”
“fmt”
)
func main() {
err := errors.New(“this is an error”)
fmt.Println(err) // 输出：this is an error
}
函数通常在最后的返回值中返回错误信息，使用 errors.New 可返回一个错误信息：
func Sqrt(f float64) (float64, error) {
if f < 0 {
return 0, errors.New(“math: square root of negative number”)
}
// 实现
}
在下面的例子中，我们在调用 Sqrt 的时候传递的一个负数，然后就得到了 non-nil 的 error 对象，将此对象与 nil 比较，结果为 true，所以 fmt.Println(fmt 包在处理 error 时会调用 Error 方法)被调用，以输出错误，请看下面调用的示例代码：
result, err:= Sqrt(-1)
if err != nil {
fmt.Println(err)
}
显式返回错误
Go 中，错误通常作为函数的返回值返回，开发者需要显式检查并处理。
显式返回错误：
实例
package main
import (
“errors”
“fmt”
)
func divide(a, b int) (int, error) {
if b == 0 {
return 0, errors.New(“division by zero”)
}
return a / b, nil
}
func main() {
result, err := divide(10, 0)
if err != nil {
fmt.Println(“Error:”, err)
} else {
fmt.Println(“Result:”, result)
}
}
输出：
Error: division by zero
自定义错误
通过定义自定义类型，可以扩展 error 接口。
自定义错误类型：
实例
package main
import (
“fmt”
)
type DivideError struct {
Dividend int
Divisor int
}
func (e *DivideError) Error() string {
return fmt.Sprintf(“cannot divide %d by %d”, e.Dividend, e.Divisor)
}
func divide(a, b int) (int, error) {
if b == 0 {
return 0, &DivideError{Dividend: a, Divisor: b}
}
return a / b, nil
}
func main() {
_, err := divide(10, 0)
if err != nil {
fmt.Println(err) // 输出：cannot divide 10 by 0
}
}
fmt 包与错误格式化
fmt 包提供了对错误的格式化输出支持：
%v：默认格式。%+v：如果支持，显示详细的错误信息。%s：作为字符串输出。
实例
package main
import (
“fmt”
)
// 定义一个 DivideError 结构
type DivideError struct {
dividee int
divider int
}
// 实现 error 接口
func (de *DivideError) Error() string {
strFormat := Cannot proceed, the divider is zero. dividee: %d divider: 0
return fmt.Sprintf(strFormat, de.dividee)
}
// 定义 int 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
if varDivider == 0 {
dData := DivideError{
dividee: varDividee,
divider: varDivider,
}
errorMsg = dData.Error()
return
} else {
return varDividee / varDivider, “”
}
}
func main() {
// 正常情况
if result, errorMsg := Divide(100, 10); errorMsg == “” {
fmt.Println(“100/10 = “, result)
}
// 当除数为零的时候会返回错误信息
if _, errorMsg := Divide(100, 0); errorMsg != “” {
fmt.Println(“errorMsg is: “, errorMsg)
}
}
执行以上程序，输出结果为：
100/10 = 10
errorMsg is:
Cannot proceed, the divider is zero.
dividee: 100
divider: 0
使用 errors.Is 和 errors.As从 Go 1.13 开始，errors 包引入了 errors.Is 和 errors.As 用于处理错误链：
errors.Is检查某个错误是否是特定错误或由该错误包装而成。
实例
package main
import (
“errors”
“fmt”
)
var ErrNotFound = errors.New(“not found”)
func findItem(id int) error {
return fmt.Errorf(“database error: %w”, ErrNotFound)
}
func main() {
err := findItem(1)
if errors.Is(err, ErrNotFound) {
fmt.Println(“Item not found”)
} else {
fmt.Println(“Other error:”, err)
}
}
errors.As
将错误转换为特定类型以便进一步处理。
实例
package main
import (
“errors”
“fmt”
)
type MyError struct {
Code int
Msg string
}
func (e *MyError) Error() string {
return fmt.Sprintf(“Code: %d, Msg: %s”, e.Code, e.Msg)
}
func getError() error {
return &MyError{Code: 404, Msg: “Not Found”}
}
func main() {
err := getError()
var myErr *MyError
if errors.As(err, &myErr) {
fmt.Printf(“Custom error - Code: %d, Msg: %s\n”, myErr.Code, myErr.Msg)
}
}
panic 和 recoverGo 的 panic 用于处理不可恢复的错误，recover 用于从 panic 中恢复。
panic:
导致程序崩溃并输出堆栈信息。常用于程序无法继续运行的情况。
recover:
捕获 panic，避免程序崩溃。
实例
package main
import “fmt”
func safeFunction() {
defer func() {
if r := recover(); r != nil {
fmt.Println(“Recovered from panic:”, r)
}
}()
panic(“something went wrong”)
}
func main() {
fmt.Println(“Starting program…”)
safeFunction()
fmt.Println(“Program continued after panic”)
}
执行以上代码，输出结果为：
Starting program…
Recovered from panic: something went wrong
Program continued after panic