第 6 章：函数与错误处理 —— 组织代码与应对意外¶

// 基本函数
fn greet(name: &str) {
    println!("你好，{}！", name);
}

// 带返回值的函数
fn add(a: i32, b: i32) -> i32 {
    a + b  // 最后一行不加分号 = 返回值
}

// 提前返回
fn absolute(x: i32) -> i32 {
    if x >= 0 {
        return x;  // 用 return 提前返回
    }
    -x  // 隐式返回
}

fn main() {
    greet("小破手");

    let sum = add(10, 20);
    println!("10 + 20 = {}", sum);

    println!("|5| = {}", absolute(5));
    println!("|-5| = {}", absolute(-5));
}

fn main() {
    let multiplier = 3;

    // 闭包：捕获了外部的 multiplier
    let multiply = |x: i32| x * multiplier;

    println!("5 * {} = {}", multiplier, multiply(5));
    println!("10 * {} = {}", multiplier, multiply(10));

    // 闭包用于迭代器
    let numbers = vec![1, 2, 3, 4, 5];

    let doubled: Vec<i32> = numbers.iter()
        .map(|x| x * 2)
        .collect();
    println!("翻倍: {:?}", doubled);

    let evens: Vec<i32> = numbers.iter()
        .filter(|&&x| x % 2 == 0)
        .copied()
        .collect();
    println!("偶数: {:?}", evens);
}

// Result 的定义（标准库中）
// enum Result<T, E> {
//     Ok(T),    // 成功，包含结果值
//     Err(E),   // 失败，包含错误信息
// }

use std::fs::File;
use std::io::Read;

fn read_file_content(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_content("存在.txt") {
        Ok(content) => println!("文件内容:\n{}", content),
        Err(e) => println!("读取失败: {}", e),
    }
}

use std::fs;
use std::io;

// 不使用 ?（啰嗦）
fn read_username_verbose() -> Result<String, io::Error> {
    let result = fs::read_to_string("username.txt");
    match result {
        Ok(content) => Ok(content.trim().to_string()),
        Err(e) => Err(e),
    }
}

// 使用 ?（简洁）
fn read_username() -> Result<String, io::Error> {
    let content = fs::read_to_string("username.txt")?;
    Ok(content.trim().to_string())
}

fn main() {
    match read_username() {
        Ok(name) => println!("用户名: {}", name),
        Err(e) => println!("读取失败: {}", e),
    }
}

fn parse_number(s: &str) -> Option<i32> {
    s.parse().ok()  // Result 转 Option
}

fn safe_divide(a: i32, b: i32) -> Result<f64, String> {
    if b == 0 {
        Err(String::from("除数不能为 0"))
    } else {
        Ok(a as f64 / b as f64)
    }
}

fn main() {
    // 解析数字
    match parse_number("42") {
        Some(n) => println!("解析成功: {}", n),
        None => println!("解析失败"),
    }

    match parse_number("abc") {
        Some(n) => println!("解析成功: {}", n),
        None => println!("解析失败"),
    }

    // 安全除法
    let results = [
        safe_divide(10, 2),
        safe_divide(10, 0),
        safe_divide(15, 3),
    ];

    for result in &results {
        match result {
            Ok(value) => println!("结果: {}", value),
            Err(e) => println!("错误: {}", e),
        }
    }
}

fn main() {
    // panic! 会让程序立即终止
    // panic!("程序遇到了无法恢复的错误！");

    let v = vec![1, 2, 3];
    // v[99];  // 索引越界，panic!

    // 使用 unwrap 和 expect
    let x: Option<i32> = Some(5);
    println!("x = {}", x.unwrap());  // 安全，因为 x 是 Some

    let y: Option<i32> = None;
    // println!("{}", y.unwrap());  // panic! 因为 y 是 None

    // expect 可以自定义错误信息
    // println!("{}", y.expect("y 不应该是 None！"));
}