Go通过error接口实现错误处理，使用errors.New和fmt.Errorf创建错误，支持自定义错误类型、哨兵错误及错误包装。
在Go语言中，错误处理是程序设计的重要组成部分。Go通过内置的error接口来表示错误，其定义非常简单：
type error interface {
Error() string
}任何实现了Error()方法的类型都可以作为错误使用。Go标准库中的errors.New和fmt.Errorf是最常用的创建错误的方式。
基本错误创建与判断
使用errors.New可以快速创建一个简单的错误：
package main
import (
"errors"
"fmt"
)
func divide(a, b float64) (float64, 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.Error())
// 输出: Error: division by zero
}
fmt.Println(result)
}你也可以用fmt.Errorf格式化生成错误信息：
立即学习“go语言免费学习笔记（深入）”；
if b == 0 {
return 0, fmt.Errorf("cannot divide %f by zero", a)
}自定义错误类型
当需要携带更多上下文信息时，可以定义自己的错误类型。例如，记录操作、时间或状态码：
type MathError struct {
Op string // 操作类型
Operand float64 // 出错的操作数
Message string // 错误描述
}
func (e *MathError) Error() string {
return fmt.Sprintf("math error during %s with operand %f: %s", e.Op, e.Operand, e.Message)
}
func safeSqrt(x float64) (float64, error) {
if x < 0 {
return 0, &MathError{
Op: "sqrt",
Operand: x,
Message: "negative input not allowed",
}
}
return math.Sqrt(x), nil
}调用后可以通过类型断言获取详细信息：
Golang Uber Dig
下载
使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等
result, err := safeSqrt(-4)
if err != nil {
if mathErr, ok := err.(*MathError); ok {
fmt.Printf("Operation: %s\n", mathErr.Op)
fmt.Printf("Operand: %f\n", mathErr.Operand)
fmt.Printf("Message: %s\n", mathErr.Message)
}
fmt.Println("Error:", err)
}使用哨兵错误（Sentinel Errors）
有时你需要预定义一些特定错误值用于比较。这种做法常见于标准库，比如io.EOF：
var ErrInsufficientFunds = errors.New("insufficient funds")
type Account struct {
Balance float64
}
func (a *Account) Withdraw(amount float64) error {
if amount > a.Balance {
return ErrInsufficientFunds
}
a.Balance -= amount
return nil
}调用方可以用errors.Is进行判断：
err := account.Withdraw(100)
if errors.Is(err, ErrInsufficientFunds) {
fmt.Println("Not enough money!")
}包装与链式错误
从Go 1.13开始，支持用%w动词包装错误，形成错误链：
func readFile(filename string) error {
data, err := os.ReadFile(filename)
if err != nil {
return fmt.Errorf("failed to read file %s: %w", filename, err)
}
// 处理数据...
return nil
}
func processFile(filename string) error {
err := readFile(filename)
if err != nil {
return fmt.Errorf("processing failed: %w", err)
}
return nil
}你可以使用errors.Unwrap、errors.Is或errors.As分析错误链：
err := processFile("nonexistent.txt")
if errors.Is(err, os.ErrNotExist) {
fmt.Println("File does not exist")
}
var pathError *os.PathError
if errors.As(err, &pathError) {
fmt.Printf("Path error occurred on path: %s\n", pathError.Path)
}总结： Go的错误处理强调显式性和可组合性。你可以根据需求选择简单字符串错误、自定义结构体错误，或利用哨兵错误和错误包装构建清晰的错误传播链。关键是让调用者能方便地识别和处理不同类型的错误情况。
基本上就这些，掌握这些模式后，你的Go项目错误处理会更规范、更易维护。
