Rust语言的错误处理机制

Rust 是一门注重安全性和性能的系统编程语言

1. Result 类型：Result 是一个 Rust 的内置枚举类型，用于表示操作可能成功（Ok）或失败（Err）。当操作成功时，Result 的 Ok 变体包含一个值；当操作失败时，Result 的 Err 变体包含一个错误信息。使用 Result 类型可以避免程序在遇到错误时崩溃，并提供一种优雅地处理错误的方法。

fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
    if b == 0 {
        Err("Division by zero")
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10, 0) {
        Ok(result) => println!("Result: {}", result),
        Err(error) => println!("Error: {}", error),
    }
}

2. panic! 宏：当程序遇到无法处理的严重错误时，可以使用 panic! 宏来终止程序并输出错误信息。这是一种紧急的错误处理方式，通常用于无法恢复的严重错误。

fn main() {
    if let Err(error) = divide(10, 0) {
        eprintln!("Panic: {}", error);
        panic!();
    }
}

3. Option 类型：Option 是一个 Rust 的内置枚举类型，用于表示值可能存在（Some）或不存在（None）。使用 Option 类型可以避免空指针异常，并提供一种优雅地处理可能缺失值的方法。

fn find_element(vec: &[i32], target: i32) -> Option<&i32> {
    vec.iter().find(|&x| x == target)
}

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

4. 自定义错误类型：除了使用内置的 Result 和 Option 类型外，还可以创建自定义的错误类型来表示和处理错误。自定义错误类型通常实现自标准库中的 Error trait，以便于与其他错误处理机制集成。

use std::fmt;

#[derive(Debug)]
enum CustomError {
    IOError(std::io::Error),
    ParseError(std::num::ParseIntError),
}

impl fmt::Display for CustomError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CustomError::IOError(ref err) => write!(f, "IO error: {}", err),
            CustomError::ParseError(ref err) => write!(f, "Parse error: {}", err),
        }
    }
}

impl From<std::io::Error> for CustomError {
    fn from(err: std::io::Error) -> CustomError {
        CustomError::IOError(err)
    }
}

impl From<std::num::ParseIntError> for CustomError {
    fn from(err: std::num::ParseIntError) -> CustomError {
        CustomError::ParseError(err)
    }
}

fn parse_number(s: &str) -> Result<i32, CustomError> {
    s.parse::<i32>().map_err(CustomError::from)
}

fn main() {
    match parse_number("123") {
        Ok(number) => println!("Parsed number: {}", number),
        Err(error) => println!("Error: {}", error),
    }
}

总之，Rust 提供了多种错误处理机制，包括 Result、Option、panic! 和自定义错误类型。这些机制可以帮助你编写更安全、更健壮的程序。