入门Rust的固定套路：错误处理模式有三大类，帮你总结了

Ok()
Err()

/// Result的定义在 rust核心代码 src/rust/library/core/src/result.rs 代码文件中：
/// `Result` is a type that represents either success ([`Ok`]) or failure ([`Err`]).
///
/// See the [module documentation](self "module documentation") for details.
#[derive(Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
#[must_use = "this `Result` may be an `Err` variant, which should be handled"]
#[rustc_diagnostic_item = "Result"]
#[stable(feature = "rust1", since = "1.0.0")]
pub enum Result<T, E> {
    /// Contains the success value
    #[lang = "Ok"]
    #[stable(feature = "rust1", since = "1.0.0")]
    Ok(#[stable(feature = "rust1", since = "1.0.0")] T),

    /// Contains the error value
    #[lang = "Err"]
    #[stable(feature = "rust1", since = "1.0.0")]
    Err(#[stable(feature = "rust1", since = "1.0.0")] E),
}

/// 代码文件 rustlib/src/rust/library/core/src/option.rs 定义了Option
/// The `Option` type. See [the module level documentation](self "the module level documentation") for more.
#[derive(Copy, PartialOrd, Eq, Ord, Debug, Hash)]
#[rustc_diagnostic_item = "Option"]
#[lang = "Option"]
#[stable(feature = "rust1", since = "1.0.0")]
pub enum Option<T> {
    /// No value.
    #[lang = "None"]
    #[stable(feature = "rust1", since = "1.0.0")]
    None,
    /// Some value of type `T`.
    #[lang = "Some"]
    #[stable(feature = "rust1", since = "1.0.0")]
    Some(#[stable(feature = "rust1", since = "1.0.0")] T),
}

use std::fs::File;
use std::io::Error;

fn open_file(file_path: &str) -> Result<File, Error> {
    let mut file = File::open(file_path)?;
    Ok(file)
    
}

pub fn open<P>(path: P) -> io::Result<File>

let mut file = File::open(file_path)?;

use std::fs::File;
use std::io::Error;

/// 演示打开文件，返回Result<File, Error> 类型的值，然后被main()中的match方式处理
fn open_file(file_path: &str) -> Result<File, Error> {
    let mut file = File::open(file_path)?;
    Ok(file)
}

fn main() {
    let file_path = "file.txt";
    let file = open_file(file_path);
    match file {
        Ok(file) => println!("文件打开成功 {:?}", file),
        Err(error) => println!("文件打开失败 {}", error),
    }
}

use std::fs::File;
use std::io::ErrorKind;
use std::io::{Error, Read};

/// 演示文件打开时 如何返回Option<T> 类型值
fn open_file(file_path: &str) -> Option<File> {
    let mut file = File::open(file_path).unwrap();
    Some(file)
}

/// 演示 match 如何处理 Option<T> 类型值，其中有None类型的情况
fn read_file(file: Option<File>) -> Result<String, Error> {
    match file {
        //处理文件的正常情况
        Some(mut file) => {
            let mut buffer = String::new();
            let file_content = file.read_to_string(&mut buffer);
            Ok(buffer)
        }
        //处理文件的异常情况
        None => Err(Error::new(ErrorKind::NotFound, "File not found")),
    }
}

fn main() {
    let file_path = "file.txt";
    let file = open_file(&file_path);
    let strings_in_file = read_file(file);

    /// 在文件 file.txt 不存在的情况下，以下代码会导致软件崩溃。
    println!("{}", strings_in_file.unwrap());

    ///echo "1111">> file.txt
    /// 创建 file.txt文件
    /// 然后重复上面代码
}

let  final_value = if let Some(T) = Rust语句 {
    //语句正确和成功的情况，如获取有效数据，将作为作用域的返回值赋值给final_value 
} else {
    //错误或异常的情况的处理，如赋值为""，同样会作为作用域的返回值赋值给 final_value 
}

#![allow(dead_code)]
#[derive(Debug)] enum Food { CordonBleu, Steak, Sushi }
#[derive(Debug)] enum Day { Monday, Tuesday, Wednesday }
// 我们没有原材料（ingredient）来制作寿司。
fn have_ingredients(food: Food) -> Option<Food> {
    match food {
        Food::Sushi => None,
        _           => Some(food),
    }
}
// 我们拥有全部食物的食谱，除了欠缺高超的烹饪手艺。
fn have_recipe(food: Food) -> Option<Food> {
    match food {
        Food::CordonBleu => None,
        _                => Some(food),
    }
}
// 做一份好菜，我们需要原材料和食谱这两者。
// 我们可以借助一系列 `match` 来表达相应的逻辑：
// （原文：We can represent the logic with a chain of `match`es:）
fn cookable_v1(food: Food) -> Option<Food> {
    match have_ingredients(food) {
        None       => None,
        Some(food) => match have_recipe(food) {
            None       => None,
            Some(food) => Some(food),
        },
    }
}
// 这可以使用 `and_then()` 方便重写出更紧凑的代码：
fn cookable_v2(food: Food) -> Option<Food> {
    have_ingredients(food).and_then(have_recipe)
}
fn eat(food: Food, day: Day) {
    match cookable_v2(food) {
        Some(food) => println!("Yay! On {:?} we get to eat {:?}.", day, food),
        None       => println!("Oh no. We don't get to eat on {:?}?", day),
    }
}
fn main() {
    let (cordon_bleu, steak, sushi) = (Food::CordonBleu, Food::Steak, Food::Sushi);
    eat(cordon_bleu, Day::Monday);
    eat(steak, Day::Tuesday);
    eat(sushi, Day::Wednesday);
}