Rust 中错误处理 (Error Handling) 的方式有哪些？-JavaScript中文网-JavaScript教程资源分享门户

本题详细解读

`Result<T, E>` 类型

Result 是 Rust 中最常用的错误处理方式。它用于表示一个操作可能成功或失败。Result 的定义如下：

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

Ok(T) 表示操作成功，并包含成功的结果 T。
Err(E) 表示操作失败，并包含错误信息 E。

使用 Result 时，通常需要显式处理 Ok 和 Err 两种情况。例如：

// www.javascriptcn.com code example
fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("Division by zero"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(4.0, 2.0) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

`Option<T>` 类型

Option 用于处理可能为空的值。它的定义如下：

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

Some(T) 表示有值 T。
None 表示没有值。

Option 通常用于处理可能返回空值的函数。例如：

// www.javascriptcn.com code example
fn find_element(arr: &[i32], target: i32) -> Option<usize> {
    for (i, &item) in arr.iter().enumerate() {
        if item == target {
            return Some(i);
        }
    }
    None
}

fn main() {
    let arr = [1, 2, 3, 4, 5];
    match find_element(&arr, 3) {
        Some(index) => println!("Found at index: {}", index),
        None => println!("Not found"),
    }
}

`panic!` 宏

panic! 用于在遇到不可恢复的错误时终止程序执行。它会打印错误信息并终止程序。例如：

fn main() {
    let x = Some(5);
    let y = x.expect("x should not be None"); // 如果 x 是 None，程序会 panic
    println!("y: {}", y);
}

`unwrap()` 和 `expect()` 方法

unwrap() 和 expect() 是 Result 和 Option 的方法，用于提取值。如果值是 Err 或 None，程序会 panic。

unwrap()：如果值是 Ok 或 Some，返回内部的值；否则 panic。
expect()：与 unwrap() 类似，但可以指定 panic 时的错误信息。

例如：

fn main() {
    let x: Option<i32> = Some(5);
    let y = x.unwrap(); // y = 5

    let z: Result<i32, &str> = Err("error");
    let w = z.expect("Failed to get value"); // 这里会 panic
}

`?` 操作符

? 操作符用于简化错误处理。它可以自动将 Result 或 Option 中的错误传播到调用者。例如：

// www.javascriptcn.com code example
fn read_file() -> Result<String, std::io::Error> {
    let mut file = std::fs::File::open("file.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() {
    match read_file() {
        Ok(contents) => println!("File contents: {}", contents),
        Err(e) => println!("Error reading file: {}", e),
    }
}

自定义错误类型

通过实现 std::error::Error trait，可以定义自己的错误类型。例如：

// www.javascriptcn.com code example
use std::fmt;

#[derive(Debug)]
struct MyError {
    details: String,
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.details)
    }
}

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

fn my_function() -> Result<(), MyError> {
    Err(MyError {
        details: String::from("Something went wrong"),
    })
}

fn main() {
    match my_function() {
        Ok(()) => println!("Success"),
        Err(e) => println!("Error: {}", e),
    }
}

Rust 中错误处理 (Error Handling) 的方式有哪些？

推荐答案

本题详细解读

Result<T, E> 类型

Option<T> 类型

panic! 宏

unwrap() 和 expect() 方法

? 操作符