Go语言错误处理：Error vs Panic

Go语言错误处理：Error vs Panic

1. Go语言错误处理哲学

Go语言的错误处理模式是其设计哲学的核心体现。与其他语言使用异常（Exception）不同，Go采用显式的错误返回值来处理可恢复的错误。这种设计让开发者完全掌控代码的执行流程，避免了异常带来的隐式跳转和难以追踪的控制流。

Go语言错误处理的核心原则是：

• 错误是值：error是一个普通的接口类型，可以像值一样被传递和操作
• 显式处理：函数通过返回值返回错误，调用者必须显式处理
• 简单直接：没有try-catch-finally那样的复杂语法结构

// error是一个内置接口 type error interface { Error() string }

2. error接口设计与自定义错误

2.1 最简单的错误创建

Go标准库提供了多种创建错误的方式：

package main import ( "errors" "fmt" ) func main() { // 使用errors.New创建简单错误 err1 := errors.New("something went wrong") fmt.Println(err1) // 使用fmt.Errorf创建格式化错误 err2 := fmt.Errorf("user %d not found", 123) fmt.Println(err2) }

2.2 自定义错误类型

对于复杂的错误场景，我们可以定义自己的错误类型：

package user import ( "fmt" "net/http" ) // ErrorCode 错误代码 type ErrorCode int const ( ErrCodeNotFound ErrorCode = 404 ErrCodeUnauthorized ErrorCode = 401 ErrCodeForbidden ErrorCode = 403 ErrCodeInternal ErrorCode = 500 ) // UserError 自定义用户错误 type UserError struct { Code ErrorCode Message string Details string } // Error 实现error接口 func (e *UserError) Error() string { return fmt.Sprintf("user error: [%d] %s - %s", e.Code, e.Message, e.Details) } // NewUserError 构造函数 func NewUserError(code ErrorCode, message, details string) *UserError { return &UserError{ Code: code, Message: message, Details: details, } } // IsUserError 检查是否是用户错误 func IsUserError(err error) bool { _, ok := err.(*UserError) return ok } // GetUserError 获取用户错误码 func GetUserErrorCode(err error) ErrorCode { if userErr, ok := err.(*UserError); ok { return userErr.Code } return ErrCodeInternal }

使用自定义错误：

package user import ( "errors" "testing" ) func TestUserError(t *testing.T) { err := NewUserError(ErrCodeNotFound, "User not found", "user id = 123") if err.Code != ErrCodeNotFound { t.Errorf("expected error code %d, got %d", ErrCodeNotFound, err.Code) } if !IsUserError(err) { t.Error("expected IsUserError to return true") } if GetUserErrorCode(err) != ErrCodeNotFound { t.Errorf("expected GetUserErrorCode to return %d", ErrCodeNotFound) } } func TestIsUserError_NilError(t *testing.T) { if IsUserError(nil) { t.Error("IsUserError should return false for nil error") } }

2.3 错误包装（Error Wrapping）

Go 1.13引入了错误包装机制，允许我们在传播错误的同时保留原始错误的上下文：

package service import ( "errors" "fmt" ) // 底层错误 var ErrUserNotFound = errors.New("user not found") // 业务层错误 type ServiceError struct { Operation string Cause error } func (s *ServiceError) Error() string { return fmt.Sprintf("service error: operation %s failed: %v", s.Operation, s.Cause) } func (s *ServiceError) Unwrap() error { return s.Cause } // NewServiceError 创建服务错误 func NewServiceError(op string, cause error) *ServiceError { return &ServiceError{ Operation: op, Cause: cause, } } // GetUser 获取用户（演示错误包装） func GetUser(id int) error { if id <= 0 { return NewServiceError("get_user", ErrUserNotFound) } // 正常逻辑... return nil }

使用fmt.Errorf进行错误包装：

package main import ( "errors" "fmt" ) func main() { baseErr := errors.New("database connection failed") // 使用%w包装错误 wrappedErr := fmt.Errorf("user service: %w", baseErr) fmt.Println("Wrapped error:", wrappedErr) // 使用errors.Is检查错误链 if errors.Is(wrappedErr, baseErr) { fmt.Println("errors.Is: wrappedErr contains baseErr") } // 使用errors.As获取具体类型 var serviceErr *ServiceError if errors.As(wrappedErr, &serviceErr) { fmt.Println("errors.As: got ServiceError") } }

errors.Is和errors.As的使用：

package service import ( "errors" "testing" ) func TestErrorWrapping(t *testing.T) { t.Run("errors.Is", func(t *testing.T) { err := GetUser(0) // 检查错误链中是否包含特定错误 if !errors.Is(err, ErrUserNotFound) { t.Error("expected error chain to contain ErrUserNotFound") } }) t.Run("errors.As", func(t *testing.T) { err := GetUser(0) // 从错误链中提取特定类型 var svcErr *ServiceError if !errors.As(err, &svcErr) { t.Error("expected error chain to contain *ServiceError") } else if svcErr.Operation != "get_user" { t.Errorf("expected operation 'get_user', got '%s'", svcErr.Operation) } }) }

3. Panic与Recover机制

3.1 Panic的使用场景

panic用于处理真正的不可恢复错误。在Go中，panic会导致程序中断并开始堆栈展开。与异常不同，Go的panic应该极少使用，主要用于以下场景：

• 编程错误：如数组越界、空指针解引用
• 不可恢复的错误：如启动失败、配置错误
• 立即终止是正确行为的情况

package config import ( "fmt" ) // MustLoad 必须成功加载配置，否则panic func MustLoad(path string) *Config { cfg, err := LoadConfig(path) if err != nil { panic(fmt.Sprintf("failed to load config from %s: %v", path, err)) } return cfg } // Config 配置 type Config struct { Port int Host string } // LoadConfig 加载配置 func LoadConfig(path string) (*Config, error) { // 模拟加载失败 return nil, fmt.Errorf("config file not found: %s", path) }

3.2 Recover捕获Panic

recover可以在defer函数中捕获panic，防止程序崩溃：

package server import ( "fmt" "log" "net/http" ) // panic处理器中间件 func PanicHandler(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { defer func() { if err := recover(); err != nil { log.Printf("panic recovered: %v", err) http.Error(w, "Internal Server Error", http.StatusInternalServerError) } }() next.ServeHTTP(w, r) }) } // 可能panic的处理器 func MyHandler(w http.ResponseWriter, r *http.Request) { panic("something went wrong") }

3.3 Recover的高级用法

package recovery import ( "fmt" "runtime" "strings" ) // PanicInfo panic信息 type PanicInfo struct { Message interface{} Stack string Function string } // RecoverWithInfo 捕获panic并返回详细信息 func RecoverWithInfo() *PanicInfo { defer func() { if r := recover(); r != nil { info := &PanicInfo{ Message: r, } // 获取堆栈信息 buf := make([]byte, 4096) n := runtime.Stack(buf, false) info.Stack = string(buf[:n]) // 获取触发的函数名 if idx := strings.Index(info.Stack, "\n"); idx > 0 { line := info.Stack[:idx] if start := strings.LastIndex(line, " "); start > 0 { info.Function = strings.TrimSpace(line[start:]) } } // 这里可以重新panic或记录日志 fmt.Printf("recovered panic: %v\n%s\n", info.Message, info.Stack) } }() return nil } // RiskyFunction 可能panic的函数 func RiskyFunction() { panic("deliberate panic") } // SafeCall 安全调用函数 func SafeCall() (err error) { defer func() { if r := recover(); r != nil { err = fmt.Errorf("caught panic: %v", r) } }() RiskyFunction() return nil }

4. Error vs Panic：如何选择

4.1 选择错误的原则

4.2 实际应用示例

package validator import ( "errors" "fmt" ) // 验证错误 var ( ErrInvalidEmail = errors.New("invalid email format") ErrInvalidPassword = errors.New("password must be at least 8 characters") ErrUserExists = errors.New("user already exists") ) // ValidateEmail 验证邮箱 func ValidateEmail(email string) error { if email == "" { return errors.New("email cannot be empty") } if !contains(email, "@") { return ErrInvalidEmail } return nil } // ValidatePassword 验证密码 func ValidatePassword(password string) error { if len(password) < 8 { return ErrInvalidPassword } return nil } // UserRegistration 用户注册 type UserRegistration struct { Email string Password string } // RegisterUser 注册用户 func RegisterUser(req UserRegistration) error { // 验证输入 if err := ValidateEmail(req.Email); err != nil { return fmt.Errorf("email validation failed: %w", err) } if err := ValidatePassword(req.Password); err != nil { return fmt.Errorf("password validation failed: %w", err) } // 检查用户是否已存在 exists, err := checkUserExists(req.Email) if err != nil { return fmt.Errorf("checking user existence: %w", err) } if exists { return ErrUserExists } // 创建用户... return nil } // 模拟数据库查询 func checkUserExists(email string) (bool, error) { return false, nil // 简化实现 } // contains 检查字符串是否包含子串 func contains(s, substr string) bool { return len(s) >= len(substr) && findSubstring(s, substr) } func findSubstring(s, substr string) bool { for i := 0; i <= len(s)-len(substr); i++ { if s[i:i+len(substr)] == substr { return true } } return false }

4.3 错误处理的最佳实践

package bestpractices import ( "errors" "fmt" "log" "os" ) // 不要忽略错误 func BadPractice() { file, _ := os.Open("test.txt") // 错误被忽略！ defer file.Close() } // GoodPractice 正确处理错误 func GoodPractice() { file, err := os.Open("test.txt") if err != nil { log.Printf("failed to open file: %v", err) return } defer file.Close() } // 不要在循环中重复处理相同错误 func BadLoopPractice(items []string) error { for _, item := range items { if err := processItem(item); err != nil { return fmt.Errorf("processing %s: %w", item, err) // 错误信息冗余 } } return nil } func processItem(item string) error { return nil } // 错误包装要适度 func BadWrapping(err error) error { return fmt.Errorf("failed: %w", err) // 过度包装 } // 保留关键上下文 func GoodWrapping(err error) error { return fmt.Errorf("database query failed: %w", err) // 清晰的上下文 }

5. 错误日志记录

5.1 分级日志记录

package logging import ( "log" "os" ) // LogLevel 日志级别 type LogLevel int const ( DEBUG LogLevel = iota INFO WARN ERROR ) // Logger 日志记录器 type Logger struct { level LogLevel output *os.File } // NewLogger 创建日志记录器 func NewLogger(level LogLevel) *Logger { return &Logger{ level: level, output: os.Stderr, } } // Debug 调试日志 func (l *Logger) Debug(format string, args ...interface{}) { if l.level <= DEBUG { log.Printf("[DEBUG] "+format, args...) } } // Info 信息日志 func (l *Logger) Info(format string, args ...interface{}) { if l.level <= INFO { log.Printf("[INFO] "+format, args...) } } // Warn 警告日志 func (l *Logger) Warn(format string, args ...interface{}) { if l.level <= WARN { log.Printf("[WARN] "+format, args...) } } // Error 错误日志 func (l *Logger) Error(err error, format string, args ...interface{}) { if l.level <= ERROR { log.Printf("[ERROR] "+format+": %v", append(args, err)...) } }

5.2 结构化错误日志

package structured import ( "encoding/json" "fmt" "log" "time" ) // ErrorLogEntry 错误日志条目 type ErrorLogEntry struct { Timestamp time.Time `json:"timestamp"` Message string `json:"message"` Error string `json:"error"` Cause string `json:"cause,omitempty"` Context map[string]interface{} `json:"context,omitempty"` } // LogError 记录结构化错误 func LogError(err error, message string, context map[string]interface{}) { entry := ErrorLogEntry{ Timestamp: time.Now(), Message: message, Error: err.Error(), Context: context, } data, _ := json.Marshal(entry) log.Printf("%s", data) } // ErrorWithContext 带上下文的错误 type ErrorWithContext struct { Err error Context map[string]interface{} } func (e *ErrorWithContext) Error() string { return fmt.Sprintf("%v (context: %v)", e.Err, e.Context) } func (e *ErrorWithContext) Unwrap() error { return e.Err } // NewErrorWithContext 创建带上下文的错误 func NewErrorWithContext(err error, ctx map[string]interface{}) *ErrorWithContext { return &ErrorWithContext{ Err: err, Context: ctx, } }

6. 实战：完整的错误处理模式

package biz import ( "errors" "fmt" ) // 业务错误定义 var ( ErrNotFound = errors.New("resource not found") ErrUnauthorized = errors.New("unauthorized operation") ErrInvalidInput = errors.New("invalid input") ErrInternalServer = errors.New("internal server error") ) // ErrorType 错误类型 type ErrorType int const ( TypeNotFound ErrorType = iota TypeValidation TypeUnauthorized TypeInternal ) // BizError 业务错误 type BizError struct { Type ErrorType Code string Message string Cause error } func (e *BizError) Error() string { if e.Cause != nil { return fmt.Sprintf("%s: %v", e.Message, e.Cause) } return e.Message } func (e *BizError) Unwrap() error { return e.Cause } // NewBizError 创建业务错误 func NewBizError(t ErrorType, code, msg string, cause error) *BizError { return &BizError{ Type: t, Code: code, Message: msg, Cause: cause, } } // IsBizError 检查是否是业务错误 func IsBizError(err error) (*BizError, bool) { var bizErr *BizError if ok := errors.As(err, &bizErr); ok { return bizErr, true } return nil, false } // UserService 用户服务 type UserService struct { // 依赖注入 } // User 用户 type User struct { ID int Email string } // GetUser 获取用户 func (s *UserService) GetUser(id int) (*User, error) { if id <= 0 { return nil, NewBizError(TypeValidation, "INVALID_ID", "user id must be positive", nil) } // 模拟数据库查询 if id == 999 { return nil, ErrNotFound } return &User{ID: id, Email: "user@example.com"}, nil } // UpdateUser 更新用户 func (s *UserService) UpdateUser(id int, email string) error { // 参数验证 if id <= 0 { return NewBizError(TypeValidation, "INVALID_ID", "user id must be positive", nil) } if email == "" { return NewBizError(TypeValidation, "INVALID_EMAIL", "email cannot be empty", nil) } // 检查用户是否存在 user, err := s.GetUser(id) if err != nil { return fmt.Errorf("failed to get user: %w", err) } // 更新用户 user.Email = email return nil } // 使用示例 func ExampleErrorHandling() { svc := &UserService{} user, err := svc.GetUser(999) if err != nil { if bizErr, ok := IsBizError(err); ok { fmt.Printf("Business error: type=%d, code=%s, msg=%s\n", bizErr.Type, bizErr.Code, bizErr.Message) } else if errors.Is(err, ErrNotFound) { fmt.Println("Resource not found") } else { fmt.Printf("Unexpected error: %v\n", err) } return } fmt.Printf("Got user: %+v\n", user) }

7. 错误处理总结

核心原则

1. 优先使用error：几乎所有可恢复的错误都应该使用error
2. 明确错误类型：定义清晰的错误类型和错误码
3. 适当包装：保留错误链，便于问题追溯
4. 避免panic：只在真正不可恢复的情况下使用panic
5. 记录日志：错误发生时记录足够的上下文信息

错误处理检查清单

• 所有函数返回值中的error都被正确检查
• 错误信息包含足够的上下文用于调试
• 错误在传播过程中被适当包装
• 关键业务错误定义了专用错误类型
• panic被限制在最小范围内，并有recover保护
• 错误日志包含时间戳、请求ID等追踪信息
• 单元测试覆盖了主要的错误路径

常见错误避免

// ❌ 忽略错误 file, _ := os.Open("test.txt") // ✓ 正确处理 file, err := os.Open("test.txt") if err != nil { return fmt.Errorf("open file failed: %w", err) } // ❌ 过度包装 return fmt.Errorf("failed: %w", err) // ✓ 适度包装 return fmt.Errorf("process user data: %w", err) // ❌ 在库中使用panic func Parse(input string) { if input == "" { panic("empty input") // 库不应该panic } } // ✓ 在库中返回error func Parse(input string) error { if input == "" { return errors.New("empty input") } return nil }

通过遵循这些最佳实践，我们可以构建健壮、可维护的Go应用程序，让错误处理成为提高代码质量的有力工具，而不是负担。