Rust错误处理模式：从Result到自定义错误类型

最新推荐文章于 2026-06-22 22:35:00 发布

原创最新推荐文章于 2026-06-22 22:35:00 发布 · 195 阅读

4 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#rust #github #python

Rust错误处理模式：从Result到自定义错误类型

引言

错误处理是编写健壮代码的关键。Rust提供了强大的错误处理机制，通过Result和Option类型在编译时强制处理错误。

本文将深入探讨Rust中的错误处理模式，包括标准错误类型、自定义错误、错误转换和最佳实践。

一、基本错误处理

1.1 Result类型

use std::fs::File;
use std::io::Read;

fn read_file_contents(path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() {
    match read_file_contents("example.txt") {
        Ok(contents) => println!("File contents: {}", contents),
        Err(e) => eprintln!("Error reading file: {}", e),
    }
}

1.2 Option类型

fn find_user(id: u32) -> Option<String> {
    let users = vec![(1, "Alice"), (2, "Bob"), (3, "Charlie")];
    
    users.into_iter()
        .find(|(user_id, _)| *user_id == id)
        .map(|(_, name)| name.to_string())
}

fn main() {
    match find_user(2) {
        Some(name) => println!("Found user: {}", name),
        None => println!("User not found"),
    }
    
    let name = find_user(5).unwrap_or_else(|| "Unknown".to_string());
    println!("User: {}", name);
}

二、自定义错误类型

2.1 使用enum定义错误类型

use std::fmt;

#[derive(Debug)]
enum AppError {
    IoError(std::io::Error),
    ParseError(String),
    ValidationError { field: String, message: String },
    NotFound,
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::IoError(e) => write!(f, "IO error: {}", e),
            AppError::ParseError(s) => write!(f, "Parse error: {}", s),
            AppError::ValidationError { field, message } => {
                write!(f, "Validation error in {}: {}", field, message)
            }
            AppError::NotFound => write!(f, "Resource not found"),
        }
    }
}

impl std::error::Error for AppError {}

2.2 使用thiserror简化错误定义

use thiserror::Error;

#[derive(Error, Debug)]
enum DatabaseError {
    #[error("Connection failed: {0}")]
    ConnectionError(#[from] std::io::Error),
    
    #[error("Query execution failed: {0}")]
    QueryError(String),
    
    #[error("Record not found with id: {0}")]
    RecordNotFound(u64),
    
    #[error("Invalid query: {0}")]
    InvalidQuery {
        query: String,
        reason: String,
    },
}

fn execute_query(query: &str) -> Result<(), DatabaseError> {
    if query.is_empty() {
        return Err(DatabaseError::InvalidQuery {
            query: query.to_string(),
            reason: "Query cannot be empty".to_string(),
        });
    }
    Ok(())
}

三、错误转换

3.1 使用From trait

use std::io;
use std::num::ParseIntError;

enum ConversionError {
    IoError(io::Error),
    ParseError(ParseIntError),
}

impl From<io::Error> for ConversionError {
    fn from(e: io::Error) -> Self {
        ConversionError::IoError(e)
    }
}

impl From<ParseIntError> for ConversionError {
    fn from(e: ParseIntError) -> Self {
        ConversionError::ParseError(e)
    }
}

fn read_and_parse(path: &str) -> Result<i32, ConversionError> {
    let mut contents = String::new();
    std::fs::File::open(path)?.read_to_string(&mut contents)?;
    let value = contents.trim().parse()?;
    Ok(value)
}

3.2 使用?操作符

fn process_data() -> Result<String, Box<dyn std::error::Error>> {
    let data = read_file_contents("data.txt")?;
    let parsed = parse_data(&data)?;
    Ok(format!("Processed: {}", parsed))
}

fn read_file_contents(path: &str) -> Result<String, std::io::Error> {
    std::fs::read_to_string(path)
}

fn parse_data(data: &str) -> Result<i32, std::num::ParseIntError> {
    data.parse()
}

四、错误处理模式

4.1 early return模式

fn validate_user(user: &User) -> Result<(), ValidationError> {
    if user.name.is_empty() {
        return Err(ValidationError::EmptyName);
    }
    
    if user.email.is_empty() {
        return Err(ValidationError::EmptyEmail);
    }
    
    if !user.email.contains('@') {
        return Err(ValidationError::InvalidEmail);
    }
    
    Ok(())
}

struct User {
    name: String,
    email: String,
}

#[derive(Debug)]
enum ValidationError {
    EmptyName,
    EmptyEmail,
    InvalidEmail,
}

4.2 错误恢复模式

fn get_config_value(key: &str) -> Result<String, ConfigError> {
    // 首先尝试从环境变量获取
    if let Ok(value) = std::env::var(key) {
        return Ok(value);
    }
    
    // 如果失败，尝试从配置文件获取
    let config = load_config()?;
    config.get(key)
        .cloned()
        .ok_or(ConfigError::KeyNotFound(key.to_string()))
}

enum ConfigError {
    IoError(std::io::Error),
    ParseError(serde_json::Error),
    KeyNotFound(String),
}

4.3 错误包装模式

use std::error::Error;

#[derive(Debug)]
struct WrappedError {
    source: Box<dyn Error + Send + Sync + 'static>,
    context: String,
}

impl WrappedError {
    fn new<E>(source: E, context: &str) -> Self
    where
        E: Error + Send + Sync + 'static,
    {
        WrappedError {
            source: Box::new(source),
            context: context.to_string(),
        }
    }
}

impl std::fmt::Display for WrappedError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}: {}", self.context, self.source)
    }
}

impl Error for WrappedError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        Some(&*self.source)
    }
}

五、错误处理最佳实践

5.1 使用anyhow进行简化

use anyhow::{Context, Result};

fn process_file(path: &str) -> Result<String> {
    let contents = std::fs::read_to_string(path)
        .with_context(|| format!("Failed to read file: {}", path))?;
    
    let data = parse_contents(&contents)
        .with_context(|| "Failed to parse contents")?;
    
    Ok(data)
}

fn parse_contents(contents: &str) -> Result<String> {
    if contents.is_empty() {
        anyhow::bail!("Contents cannot be empty");
    }
    Ok(contents.to_string())
}

5.2 使用eyre进行更优雅的错误处理

use eyre::{eyre, Result, WrapErr};

fn main() -> Result<()> {
    let config = load_config().wrap_err("Failed to load configuration")?;
    let connection = connect_to_database(&config)
        .wrap_err("Failed to connect to database")?;
    
    Ok(())
}

fn load_config() -> Result<Config> {
    Err(eyre!("Configuration file not found"))
}

struct Config;

fn connect_to_database(_config: &Config) -> Result<()> {
    Ok(())
}

5.3 错误日志记录

use log::{error, info};

fn process_request(request: Request) -> Result<Response, AppError> {
    info!("Processing request: {:?}", request);
    
    let result = do_processing(&request).map_err(|e| {
        error!("Processing failed: {}", e);
        e
    })?;
    
    Ok(result)
}

struct Request;
struct Response;

fn do_processing(_request: &Request) -> Result<Response, AppError> {
    Err(AppError::ProcessingError)
}

#[derive(Debug)]
enum AppError {
    ProcessingError,
}

impl std::fmt::Display for AppError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl std::error::Error for AppError {}