Rust 錯誤處理高級應(yīng)用最佳實踐

更新時間：2026年04月28日 09:10:08 作者：第一程序員

本文介紹了Rust錯誤處理模型,重點講解了Result類型、自定義錯誤、錯誤傳播與轉(zhuǎn)換、錯誤鏈等概念,并以文件操作、網(wǎng)絡(luò)請求、數(shù)據(jù)庫操作為例展示了其實戰(zhàn)應(yīng)用,最后總結(jié)了最佳實踐,通過學(xué)習(xí),可以編寫更加健壯、可維護(hù)的代碼,感興趣的朋友一起看看吧

1. 錯誤處理基礎(chǔ)

Rust 的錯誤處理模型基于 Result 類型，它允許我們優(yōu)雅地處理可能失敗的操作。

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}
fn main() {
    match divide(10.0, 2.0) {
        Ok(result) => println!("Result: {}", result),
        Err(error) => println!("Error: {}", error),
    }
}

2. 自定義錯誤類型

2.1 使用枚舉定義錯誤類型

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, "Negative square root"),
        }
    }
}
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())
    }
}
fn main() {
    match divide(10.0, 2.0) {
        Ok(result) => println!("Division result: {}", result),
        Err(error) => println!("Division error: {}", error),
    }
    match sqrt(-1.0) {
        Ok(result) => println!("Square root result: {}", result),
        Err(error) => println!("Square root error: {}", error),
    }
}

2.2 使用thiserror庫

use thiserror::Error;
#[derive(Error, Debug)]
enum MathError {
    #[error("Division by zero")]
    DivisionByZero,
    #[error("Negative square root: {0}")]
    NegativeSquareRoot(f64),
}
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(x))
    } else {
        Ok(x.sqrt())
    }
}
fn main() {
    match divide(10.0, 2.0) {
        Ok(result) => println!("Division result: {}", result),
        Err(error) => println!("Division error: {}", error),
    }
    match sqrt(-1.0) {
        Ok(result) => println!("Square root result: {}", result),
        Err(error) => println!("Square root error: {}", error),
    }
}

3. 錯誤傳播

3.1 使用?運算符

use std::fs::File;
use std::io::Read;
fn read_file(path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}
fn main() {
    match read_file("file.txt") {
        Ok(content) => println!("File content: {}", content),
        Err(error) => println!("Error: {}", error),
    }
}

3.2 錯誤轉(zhuǎn)換

use std::fs::File;
use std::io::Read;
use thiserror::Error;
#[derive(Error, Debug)]
enum AppError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    #[error("Custom error: {0}")]
    Custom(String),
}
fn read_file(path: &str) -> Result<String, AppError> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}
fn main() {
    match read_file("file.txt") {
        Ok(content) => println!("File content: {}", content),
        Err(error) => println!("Error: {}", error),
    }
}

4. 高級錯誤處理技巧

4.1 錯誤鏈

use std::fs::File;
use std::io::Read;
use thiserror::Error;
#[derive(Error, Debug)]
enum AppError {
    #[error("Failed to read file: {0}")]
    ReadFile(#[from] std::io::Error),
    #[error("Failed to parse content: {0}")]
    ParseContent(#[from] std::num::ParseIntError),
}
fn read_and_parse(path: &str) -> Result<i32, AppError> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    let number: i32 = content.trim().parse()?;
    Ok(number)
}
fn main() {
    match read_and_parse("number.txt") {
        Ok(number) => println!("Parsed number: {}", number),
        Err(error) => {
            println!("Error: {}", error);
            if let Some(source) = error.source() {
                println!("Source error: {}", source);
            }
        }
    }
}

4.2 錯誤處理與Option

fn find_element<T: PartialEq>(slice: &[T], target: &T) -> Option<usize> {
    slice.iter().position(|x| x == target)
}
fn find_element_or_error<T: PartialEq + std::fmt::Debug>(slice: &[T], target: &T) -> Result<usize, String> {
    find_element(slice, target)
        .ok_or_else(|| format!("Element {:?} not found", target))
}
fn main() {
    let numbers = [1, 2, 3, 4, 5];
    match find_element_or_error(&numbers, &3) {
        Ok(index) => println!("Found element at index: {}", index),
        Err(error) => println!("Error: {}", error),
    }
    match find_element_or_error(&numbers, &6) {
        Ok(index) => println!("Found element at index: {}", index),
        Err(error) => println!("Error: {}", error),
    }
}

4.3 自定義錯誤處理函數(shù)

use std::fs::File;
use std::io::Read;
fn handle_error<E: std::error::Error>(error: E) {
    eprintln!("Error: {}", error);
    if let Some(source) = error.source() {
        eprintln!("Source: {}", source);
    }
}
fn read_file(path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}
fn main() {
    if let Err(error) = read_file("file.txt") {
        handle_error(error);
    }
}

5. 實際應(yīng)用場景

5.1 文件操作

use std::fs::File;
use std::io::{Read, Write};
use thiserror::Error;
#[derive(Error, Debug)]
enum FileError {
    #[error("Failed to open file: {0}")]
    Open(#[from] std::io::Error),
    #[error("Failed to read file: {0}")]
    Read(#[from] std::io::Error),
    #[error("Failed to write file: {0}")]
    Write(#[from] std::io::Error),
}
fn read_file(path: &str) -> Result<String, FileError> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}
fn write_file(path: &str, content: &str) -> Result<(), FileError> {
    let mut file = File::create(path)?;
    file.write_all(content.as_bytes())?;
    Ok(())
}
fn main() {
    match read_file("input.txt") {
        Ok(content) => {
            println!("Read content: {}", content);
            if let Err(error) = write_file("output.txt", &content) {
                eprintln!("Error writing file: {}", error);
            }
        },
        Err(error) => {
            eprintln!("Error reading file: {}", error);
        },
    }
}

5.2 網(wǎng)絡(luò)請求

use reqwest::Error;
use thiserror::Error;
#[derive(Error, Debug)]
enum ApiError {
    #[error("Request failed: {0}")]
    Request(#[from] Error),
    #[error("Invalid response")]
    InvalidResponse,
}
async fn fetch_data() -> Result<String, ApiError> {
    let response = reqwest::get("https://api.example.com/data").await?;
    if response.status().is_success() {
        let data = response.text().await?;
        Ok(data)
    } else {
        Err(ApiError::InvalidResponse)
    }
}
#[tokio::main]
async fn main() {
    match fetch_data().await {
        Ok(data) => println!("Fetched data: {}", data),
        Err(error) => eprintln!("Error: {}", error),
    }
}

5.3 數(shù)據(jù)庫操作

use sqlx::postgres::PgPool;
use thiserror::Error;
#[derive(Error, Debug)]
enum DbError {
    #[error("Database connection failed: {0}")]
    Connection(#[from] sqlx::Error),
    #[error("Query failed: {0}")]
    Query(#[from] sqlx::Error),
}
async fn get_users() -> Result<Vec<(i32, String)>, DbError> {
    let pool = PgPool::connect("postgres://postgres:password@localhost/test").await?;
    let rows = sqlx::query!("SELECT id, name FROM users").fetch_all(&pool).await?;
    let users: Vec<(i32, String)> = rows.into_iter().map(|row| (row.id, row.name)).collect();
    Ok(users)
}
#[tokio::main]
async fn main() {
    match get_users().await {
        Ok(users) => {
            for (id, name) in users {
                println!("User: {} - {}", id, name);
            }
        },
        Err(error) => {
            eprintln!("Error: {}", error);
        },
    }
}