顾乔芝士网

持续更新的前后端开发技术栈

2025年10月23日

Rust编程-核心篇-错误处理_rust出现错误

在软件开发中，错误是不可避免的。网络请求可能失败，文件可能不存在，用户输入可能无效。传统的错误处理方式——异常机制——虽然方便，但往往导致程序的不确定性：错误可能在任何地方被抛出，调用者可能忘记处理异常。

Rust采用了一种不同的方法：显式错误处理。通过Result和Option类型，Rust强制在编译时考虑错误情况，让错误处理成为代码的一部分，而不是事后的补救措施。

Result类型

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Result类型表示一个操作可能成功（返回Ok(T)）或失败（返回Err(E)）。

基本用法

use std::fs::File;

fn main() {
    let f = File::open("hello.txt");
    
    let f = match f {
        Ok(file) => file,
        Err(error) => {
            panic!("Problem opening the file: {:?}", error);
        }
    };
}

不同类型的错误处理

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let f = File::open("hello.txt");
    
    let f = match f {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {:?}", e),
            },
            other_error => {
                panic!("Problem opening the file: {:?}", other_error);
            }
        },
    };
}

错误传播

Rust提供了?操作符来简化错误传播：

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username_file = File::open("hello.txt")?;
    let mut username = String::new();
    username_file.read_to_string(&mut username)?;
    Ok(username)
}

// 更简洁的版本
fn read_username_from_file() -> Result<String, io::Error> {
    let mut username = String::new();
    File::open("hello.txt")?.read_to_string(&mut username)?;
    Ok(username)
}

// 最简洁的版本
fn read_username_from_file() -> Result<String, io::Error> {
    std::fs::read_to_string("hello.txt")
}

自定义错误类型

use std::fmt;

#[derive(Debug)]
enum MathError {
    DivisionByZero,
    NegativeSquareRoot,
}

impl fmt::Display for MathError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            MathError::DivisionByZero => write!(f, "Division by zero"),
            MathError::NegativeSquareRoot => write!(f, "Square root of negative number"),
        }
    }
}

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

fn divide(a: f64, b: f64) -> Result<f64, MathError> {
    if b == 0.0 {
        Err(MathError::DivisionByZero)
    } else {
        Ok(a / b)
    }
}

fn sqrt(x: f64) -> Result<f64, MathError> {
    if x < 0.0 {
        Err(MathError::NegativeSquareRoot)
    } else {
        Ok(x.sqrt())
    }
}

错误链

使用thiserror创建结构化错误

use thiserror::Error;

#[derive(Error, Debug)]
pub enum DataProcessingError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    
    #[error("Parse error: {0}")]
    Parse(#[from] serde_json::Error),
    
    #[error("Validation error: {message}")]
    Validation { message: String },
    
    #[error("Network error: {0}")]
    Network(#[from] reqwest::Error),
}

fn process_data() -> Result<String, DataProcessingError> {
    let content = std::fs::read_to_string("data.json")?; // IO错误自动转换
    let data: serde_json::Value = serde_json::from_str(&content)?; // 解析错误自动转换
    
    if data["version"].is_null() {
        return Err(DataProcessingError::Validation {
            message: "Missing version field".to_string(),
        });
    }
    
    Ok(data["name"].as_str().unwrap_or("Unknown").to_string())
}

使用anyhow进行快速原型开发

use anyhow::{Context, Result};

fn read_config() -> Result<String> {
    let path = "config.toml";
    let content = std::fs::read_to_string(path)
        .with_context(|| format!("Failed to read config file: {}", path))?;
    
    Ok(content)
}

fn main() -> Result<()> {
    let config = read_config()?;
    println!("Config: {}", config);
    Ok(())
}

Option类型

enum Option<T> {
    Some(T),
    None,
}

基本用法

fn find_user(id: u32) -> Option<String> {
    if id == 1 {
        Some("Alice".to_string())
    } else {
        None
    }
}

fn main() {
    match find_user(1) {
        Some(name) => println!("User: {}", name),
        None => println!("User not found"),
    }
}

Option的常用方法

fn process_user(id: u32) {
    let user = find_user(id);
    
    // unwrap_or：提供默认值
    let name = user.unwrap_or("Unknown".to_string());
    
    // map：转换Some中的值
    let name_length = user.map(|name| name.len());
    
    // and_then：链式操作
    let result = user
        .and_then(|name| if name.len() > 3 { Some(name) } else { None })
        .unwrap_or("Invalid".to_string());
    
    // filter：条件过滤
    let valid_user = user.filter(|name| name.len() > 3);
    
    println!("Name: {}, Length: {:?}, Result: {}", name, name_length, result);
}

错误处理的组合子

map和map_err

use std::num::ParseIntError;

fn parse_and_double(s: &str) -> Result<i32, ParseIntError> {
    s.parse::<i32>().map(|n| n * 2)
}

fn parse_and_double_with_custom_error(s: &str) -> Result<i32, String> {
    s.parse::<i32>()
        .map(|n| n * 2)
        .map_err(|e| format!("Failed to parse '{}': {}", s, e))
}

and_then：链式操作

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

fn calculate(a: i32, b: i32, c: i32) -> Result<i32, String> {
    divide(a, b)
        .and_then(|result| divide(result, c))
        .and_then(|result| if result > 0 { Ok(result) } else { Err("Negative result".to_string()) })
}

or_else：错误恢复

fn read_config_file() -> Result<String, std::io::Error> {
    std::fs::read_to_string("config.toml")
        .or_else(|_| std::fs::read_to_string("config.default.toml"))
        .or_else(|_| Ok("default_config".to_string()))
}

实际应用

use reqwest;
use serde_json;
use std::collections::HashMap;

#[derive(Debug)]
enum ApiError {
    Network(reqwest::Error),
    Parse(serde_json::Error),
    Http(reqwest::StatusCode),
    MissingField(String),
}

impl std::fmt::Display for ApiError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            ApiError::Network(e) => write!(f, "Network error: {}", e),
            ApiError::Parse(e) => write!(f, "Parse error: {}", e),
            ApiError::Http(code) => write!(f, "HTTP error: {}", code),
            ApiError::MissingField(field) => write!(f, "Missing field: {}", field),
        }
    }
}

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

async fn fetch_user_data(user_id: u32) -> Result<HashMap<String, serde_json::Value>, ApiError> {
    let url = format!("https://api.example.com/users/{}", user_id);
    let response = reqwest::get(&url)
        .await
        .map_err(ApiError::Network)?;
    
    if !response.status().is_success() {
        return Err(ApiError::Http(response.status()));
    }
    
    let data: HashMap<String, serde_json::Value> = response
        .json()
        .await
        .map_err(ApiError::Parse)?;
    
    if !data.contains_key("name") {
        return Err(ApiError::MissingField("name".to_string()));
    }
    
    Ok(data)
}

错误处理的最佳实践

1. 使用适当的错误类型

// 不好的做法：使用String作为错误类型
fn bad_function() -> Result<i32, String> {
    Err("Something went wrong".to_string())
}

// 好的做法：使用具体的错误类型
#[derive(Debug, thiserror::Error)]
enum MyError {
    #[error("Invalid input: {0}")]
    InvalidInput(String),
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
}

fn good_function() -> Result<i32, MyError> {
    Err(MyError::InvalidInput("Invalid value".to_string()))
}

2. 提供有意义的错误信息

fn process_file(filename: &str) -> Result<String, std::io::Error> {
    std::fs::read_to_string(filename)
        .map_err(|e| {
            eprintln!("Failed to read file '{}': {}", filename, e);
            e
        })
}

3. 使用?操作符进行错误传播

// 不好的做法：手动匹配
fn bad_error_handling() -> Result<String, std::io::Error> {
    let file = match File::open("config.txt") {
        Ok(f) => f,
        Err(e) => return Err(e),
    };
    // ...
}

// 好的做法：使用?操作符
fn good_error_handling() -> Result<String, std::io::Error> {
    let mut file = File::open("config.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

性能考虑

Rust的错误处理是零成本的：

// 成功路径没有额外开销
fn fast_function() -> Result<i32, String> {
    Ok(42)  // 编译后只是一个简单的返回值
}

// 错误路径的开销也很小
fn error_function() -> Result<i32, String> {
    Err("error".to_string())  // 只是一个枚举变体
}

写在最后

Rust的错误处理系统带来了：

  1. 编译时安全：强制处理所有可能的错误情况
  2. 性能优异：零运行时开销
  3. 类型安全：错误类型是类型系统的一部分
  4. 组合性强：可以轻松组合不同的错误处理逻辑

通过显式错误处理，Rust让我们重新思考错误处理的方式。错误不再是异常，而是程序正常流程的一部分。这种设计哲学让代码更加健壮、可预测，也更容易测试和维护。

标签：s_url is invalid 

作者:gpyoja , 分类:技术文章 , 浏览:12 , 评论:0

控制面板
您好，欢迎到访网站！
  查看权限
网站分类
最新留言