Rust 控制流实战：条件、循环与模式匹配

条件运算符

Rust 提供了标准的比较和逻辑运算符，支持短路求值，这对性能优化很有帮助。

fn conditional_operators() {
    println!("\n=== 条件运算符 ===");
    
    // 1. 比较运算符
    let a = 10;
    let b = 20;
    println!("比较运算:");
    println!(" {} == {}: {}", a, b, a == b);
    println!(" {} != {}: {}", a, b, a != b);
    println!(" {} < {}: {}", a, b, a < b);
    println!(" {} > {}: {}", a, b, a > b);
    println!(" {} <= {}: {}", a, b, a <= b);
    println!(" {} >= {}: {}", a, b, a >= b);

    // 2. 逻辑运算符
    let has_permission = true;
    let has_credits = false;
    println!("逻辑运算:");
    println!(" 与运算：{}", has_permission && has_credits);
    println!(" 或运算：{}", has_permission || has_credits);
    println!(" 非运算：{}", !has_permission);

    // 3. 组合条件
    let age = 25;
    let has_license = true;
    if age >= 18 && has_license {
        println!("可以驾驶");
    } else {
        println!("不能驾驶");
    }

    // 4. 短路求值演示
    println!("\n短路求值演示:");
    fn expensive_check() -> bool {
        println!("执行昂贵检查...");
        true
    }
    let condition1 = false;
    let condition2 = true;
    // 由于 condition1 为 false，expensive_check 不会被调用
    if condition1 && expensive_check() {
        println!("条件 1 为真");
    }
    // 由于 condition2 为 true，expensive_check 会被调用
    if condition2 || expensive_check() {
        println!("条件 2 为真");
    }

    // 5. 复杂条件表达式
    let temperature = 25;
    let is_sunny = true;
    let is_weekend = false;
    let should_go_out = if temperature > 20 && temperature < 30 && is_sunny {
        if is_weekend { "绝对要出门！" } else { "天气很好，但得上班" }
    } else { "还是呆在家里吧" };
    println!("出门建议：{}", should_go_out);
}

4.1.2 高级条件表达式模式

掌握一些高级模式可以让你的代码更健壮，比如守卫子句和早期返回。

fn advanced_conditional_patterns() {
    println!("=== 高级条件表达式模式 ===");
    
    // 1. 守卫条件 (guard clauses) - 早期返回模式
    fn process_user(age: Option<u32>, has_consent: bool) -> String {
        if age.is_none() { return "年龄信息缺失".to_string(); }
        let age = age.unwrap();
        if !has_consent { return "需要用户同意".to_string(); }
        if age < 18 { return "用户未成年".to_string(); }
        "处理成功".to_string()
    }
    println!("守卫条件示例：{}", process_user(Some(20), true));

    // 2. 条件赋值模式
    let mut counter = 0;
    let max_attempts = 3;
    while let true = { counter += 1; counter <= max_attempts } {
        println!("尝试 {} of {}", counter, max_attempts);
    }

    // 3. 复杂布尔表达式
    let is_weekday = true;
    let is_holiday = false;
    let has_meeting = true;
    let workload = 75;
    let should_work_from_home = (is_weekday && !is_holiday) && (has_meeting || workload > 80);
    println!("应该在家办公：{}", should_work_from_home);

    // 4. 模式匹配风格的 if let
    let config = Some("production");
    if let Some(env) = config {
        println!("运行在 {} 环境", env);
    }

    // 5. 多变量条件绑定
    let point = (5, 10);
    if let (x, y) = point {
        if x > 0 && y > 0 {
            println!("点 ({}, {}) 在第一象限", x, y);
        }
    }

    // 6. 条件表达式与错误处理
    fn parse_number(s: &str) -> Result<i32, String> {
        if s.is_empty() { return Err("字符串为空".to_string()); }
        if !s.chars().all(|c| c.is_ascii_digit()) { return Err("包含非数字字符".to_string()); }
        Ok(s.parse().unwrap())
    }
    match parse_number("123") {
        Ok(num) => println!("解析成功：{}", num),
        Err(e) => println!("解析失败：{}", e),
    }

    // 7. 条件编译
    #[cfg(debug_assertions)]
    println!("这是调试构建");
    #[cfg(not(debug_assertions))]
    println!("这是发布构建");
}

4.2 循环：loop、while、for

4.2.1 loop 循环深度解析

loop 是 Rust 中最基础的无限循环结构，必须显式中断。

fn loop_deep_dive() {
    println!("=== loop 循环深度解析 ===");
    
    // 1. 基本 loop 循环
    let mut counter = 0;
    loop {
        counter += 1;
        println!("循环次数：{}", counter);
        if counter >= 5 { break; }
    }

    // 2. loop 返回值
    let result = loop {
        counter += 1;
        if counter >= 10 { break counter * 2; }
    };
    println!("loop 返回值：{}", result);

    // 3. 嵌套 loop 和标签
    'outer: loop {
        println!("进入外部循环");
        let mut inner_counter = 0;
        'inner: loop {
            inner_counter += 1;
            println!(" 内部循环：{}", inner_counter);
            if inner_counter >= 3 { break 'inner; }
        }
        counter += 1;
        if counter >= 2 { break 'outer; }
    }

    // 4. loop 与模式匹配
    let mut values = vec![1, 2, 3, 4, 5].into_iter();
    loop {
        match values.next() {
            Some(value) => {
                println!("处理值：{}", value);
                if value == 3 {
                    println!("找到目标值，继续处理...");
                    continue;
                }
            },
            None => {
                println!("没有更多值");
                break;
            }
        }
    }
}

4.2.2 while 循环深度解析

当条件满足时重复执行，适合已知终止条件的场景。

fn while_loop_deep_dive() {
    println!("=== while 循环深度解析 ===");
    
    // 1. 基本 while 循环
    let mut counter = 0;
    while counter < 5 {
        println!("计数器：{}", counter);
        counter += 1;
    }

    // 2. while let 模式
    let mut stack = Vec::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);
    println!("栈内容:");
    while let Some(top) = stack.pop() {
        println!("弹出：{}", top);
    }

    // 3. 复杂的 while 条件
    let mut x = 100;
    while x > 0 {
        x /= 2;
        if x == 0 { break; }
        println!("x = {}", x);
    }

    // 4. 使用 while 进行输入处理
    process_user_input_simulation();
}

fn process_user_input_simulation() {
    println!("\n=== 用户输入处理模拟 ===");
    use std::collections::VecDeque;
    let mut input_queue = VecDeque::from(["help".to_string(), "exit".to_string(), "invalid".to_string(), "status".to_string(),]);
    let mut running = true;
    while running && !input_queue.is_empty() {
        let input = input_queue.pop_front().unwrap();
        match input.as_str() {
            "help" => { println!("显示帮助信息"); },
            "exit" => { println!("退出程序"); running = false; },
            "status" => { println!("显示状态信息"); },
            _ => { println!("未知命令：{}", input); }
        }
    }
    println!("输入处理结束");
}

4.2.3 for 循环深度解析

Rust 的 for 循环主要用于迭代集合，基于 Iterator trait。

fn for_loop_deep_dive() {
    println!("=== for 循环深度解析 ===");
    
    // 1. 基本 for 循环 - 范围迭代
    println!("范围迭代:");
    for i in 0..5 { // 0 到 4（不包含 5）
        println!("i = {}", i);
    }
    println!("包含范围:");
    for i in 0..=5 { // 0 到 5（包含 5）
        println!("i = {}", i);
    }

    // 2. 数组迭代
    let numbers = [10, 20, 30, 40, 50];
    println!("数组迭代:");
    for number in numbers {
        println!("数字：{}", number);
    }

    // 3. 向量迭代
    let names = vec!["Alice", "Bob", "Charlie"];
    println!("向量迭代:");
    for name in &names { // 使用引用避免所有权转移
        println!("名字：{}", name);
    }

    // 4. 带索引的迭代
    println!("带索引迭代:");
    for (index, name) in names.iter().enumerate() {
        println!("索引 {}: {}", index, name);
    }

    // 5. 哈希映射迭代
    use std::collections::HashMap;
    let mut scores = HashMap::new();
    scores.insert("Alice", 100);
    scores.insert("Bob", 85);
    scores.insert("Charlie", 92);
    println!("哈希映射迭代:");
    for (name, score) in &scores {
        println!("{}: {}", name, score);
    }

    // 6. 反向迭代
    println!("反向迭代:");
    for i in (0..5).rev() {
        println!("i = {}", i);
    }

    // 7. 步长迭代
    println!("步长迭代:");
    for i in (0..20).step_by(3) {
        println!("i = {}", i);
    }
}

4.3 模式匹配与 match 表达式

4.3.1 match 表达式基础

match 是 Rust 最强大的控制流工具，提供全面的模式匹配能力，且强制穷尽性检查。

fn match_expression_basics() {
    println!("=== match 表达式基础 ===");
    
    // 1. 基本 match 表达式
    let number = 13;
    match number {
        1 => println!("一"),
        2 | 3 | 5 | 7 | 11 => println!("质数"),
        13..=19 => println!("青少年数字"),
        _ => println!("其他数字"),
    }

    // 2. match 返回值的用法
    let number = 5;
    let description = match number {
        1 => "一",
        2 => "二",
        3 => "三",
        _ => "很多",
    };
    println!("数字 {} 是 {}", number, description);

    // 3. 匹配布尔值
    let flag = true;
    match flag {
        true => println!("真"),
        false => println!("假"),
    }

    // 4. 匹配字符
    let grade = 'A';
    match grade {
        'A' | 'B' | 'C' => println!("及格"),
        'D' => println!("勉强及格"),
        'F' => println!("不及格"),
        _ => println!("无效成绩"),
    }

    // 5. 匹配字符串切片
    let language = "Rust";
    match language {
        "Rust" => println!("系统编程语言"),
        "Python" => println!("脚本语言"),
        "Java" => println!("企业级语言"),
        _ => println!("其他语言"),
    }

    // 6. 穷尽性检查
    let boolean = true;
    match boolean {
        true => println!("真"),
        false => println!("假"),
    }

    // 7. 使用 _ 通配符
    let value = 42;
    match value {
        1 => println!("一"),
        2 => println!("二"),
        _ => (), // 忽略其他所有情况
    }
}

4.3.2 if let 和 while let

当只需要处理部分模式时，if let 和 while let 比 match 更简洁。

fn if_let_while_let_patterns() {
    println!("=== if let 和 while let 模式 ===");
    
    // 1. 基本 if let 用法
    let some_value = Some(5);
    // 使用 match
    match some_value {
        Some(x) => println!("值为：{}", x),
        None => {},
    }
    // 使用 if let（更简洁）
    if let Some(x) = some_value {
        println!("值为：{}", x);
    }

    // 2. if let 与 else
    let none_value: Option<i32> = None;
    if let Some(x) = none_value {
        println!("有值：{}", x);
    } else {
        println!("没有值");
    }

    // 3. if let 与守卫条件
    let some_number = Some(10);
    if let Some(x) = some_number && x > 5 {
        println!("值 {} 大于 5", x);
    }

    // 4. 解构复杂类型
    enum Event {
        Click { x: i32, y: i32 },
        KeyPress(char),
    }
    let event = Event::Click { x: 100, y: 200 };
    if let Event::Click { x, y } = event {
        println!("点击位置：({}, {})", x, y);
    }

    // 5. while let 循环
    let mut stack = Vec::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);
    println!("使用 while let 弹出栈:");
    while let Some(top) = stack.pop() {
        println!("弹出：{}", top);
    }
}

4.4 控制流最佳实践

4.4.1 代码可读性与维护性

编写清晰的控制流代码能显著降低维护成本。

fn readability_best_practices() {
    println!("=== 代码可读性最佳实践 ===");
    
    // 1. 使用有意义的变量名
    let user_age = 25;
    let has_driving_license = true;
    if user_age >= 18 && has_driving_license {
        println!("可以驾驶");
    }

    // 2. 避免过深的嵌套
    complex_nested_logic();
    refactored_complex_logic();

    // 3. 使用守卫子句提前返回
    fn process_user_data(name: Option<&str>, age: Option<u32>) -> Result<String, String> {
        let name = name.ok_or("姓名缺失")?;
        let age = age.ok_or("年龄缺失")?;
        if name.is_empty() { return Err("姓名为空".to_string()); }
        if age < 18 { return Err("用户未成年".to_string()); }
        Ok(format!("用户 {} 年龄 {}", name, age))
    }

    // 4. 使用布尔变量简化复杂条件
    let temperature = 25;
    let is_weekend = true;
    let has_plans = false;
    let good_weather = temperature > 20 && temperature < 30;
    let free_time = is_weekend && !has_plans;
    if good_weather && free_time {
        println!("好天气，没安排，出门吧！");
    }
}

fn complex_nested_logic() {
    println!("\n=== 复杂嵌套逻辑（反面教材） ===");
    let user_role = "admin";
    let is_authenticated = true;
    let has_permission = true;
    let resource_available = true;
    if is_authenticated {
        if user_role == "admin" {
            if has_permission {
                if resource_available {
                    println!("操作成功");
                } else {
                    println!("资源不可用");
                }
            } else {
                println!("权限不足");
            }
        } else {
            println!("角色不符");
        }
    } else {
        println!("未认证");
    }
}

fn refactored_complex_logic() {
    println!("\n=== 重构后的逻辑 ===");
    let user_role = "admin";
    let is_authenticated = true;
    let has_permission = true;
    let resource_available = true;
    if !is_authenticated { println!("未认证"); return; }
    if user_role != "admin" { println!("角色不符"); return; }
    if !has_permission { println!("权限不足"); return; }
    if !resource_available { println!("资源不可用"); return; }
    println!("操作成功");
}

4.4.2 错误处理模式

在控制流中优雅地处理错误是 Rust 的核心优势之一。

fn error_handling_patterns() {
    println!("=== 错误处理模式 ===");
    
    // 1. 使用 Result 和 match
    fn parse_number(s: &str) -> Result<i32, String> {
        s.parse().map_err(|_| "解析失败".to_string())
    }
    let input = "42";
    match parse_number(input) {
        Ok(number) => println!("解析成功：{}", number),
        Err(error) => println!("解析失败：{}", error),
    }

    // 2. 使用 ? 操作符简化错误传播
    fn process_data(data: &str) -> Result<i32, String> {
        let num1 = parse_number(data)?;
        let num2 = parse_number("100")?;
        Ok(num1 + num2)
    }

    // 3. 可选值处理模式
    fn find_user(name: &str) -> Option<&str> {
        if name == "admin" { Some("管理员用户") } else { None }
    }
    let user = find_user("admin");
    match user {
        Some(user_info) => println!("找到用户：{}", user_info),
        None => println!("用户不存在"),
    }

    // 4. 使用 unwrap_or 提供默认值
    let user = find_user("guest").unwrap_or("默认用户");
    println!("用户：{}", user);
}

通过本章的学习，你已经掌握了 Rust 控制流的核心机制。从灵活的 if 表达式到强大的 match 模式匹配，再到各种循环结构，这些工具将帮助你构建既安全又高效的业务逻辑。下一章我们将深入探讨 Rust 的灵魂：所有权系统。