Rust 中的控制流：表达式导向与安全性的统一

控制流是任何编程语言的基本组成部分，它决定了程序执行的路径和逻辑分支。然而在 Rust 中，控制流结构不仅仅是简单的逻辑跳转工具，更是表达式系统和类型安全机制的有机组成部分。Rust 将传统的控制流语句重新设计为表达式，使得代码既能保持清晰的逻辑结构，又能以函数式的方式组合和返回值。这种设计不是表面的语法糖，而是深刻体现了 Rust 对安全性、表达力和性能的综合考量。

if 表达式：条件分支的值语义

与 C 系语言中的 if 语句不同，Rust 的 if 是表达式，可以直接产生值。这意味着我们可以用 if 表达式来初始化变量或作为函数的返回值。这种设计消除了三元运算符的需要，使得条件赋值的代码更加清晰和统一。

if 表达式要求所有分支必须返回相同类型的值，这是 Rust 类型系统的严格要求。编译器会在编译时验证类型一致性，防止了运行时的类型错误。这种约束看似限制，实则是安全性的保障——当你使用 if 表达式初始化一个变量时，无论走哪个分支，变量的类型都是确定且一致的。

从实践角度看，if 表达式鼓励我们以声明式而非命令式的方式编写代码。与其创建一个可变变量然后在不同分支中修改它，不如直接用 if 表达式根据条件产生正确的值。这种模式减少了可变性，降低了代码的复杂度，也使得代码更容易推理和测试。

fn if_as_expression() {
    let number = 42;
    
    // if 表达式初始化变量
    let category = if number < 0 {
        "negative"
    } else if number == 0 {
        "zero"
    } else if number < 100 {
        "small positive"
    } else {
        "large positive"
    };
    
    // if 作为函数返回值
    fn classify(n: i32) -> &'static str {
        if n % 2 == 0 {
            "even"
        } else {
            "odd"
        }
    }
    
    // 嵌套 if 表达式
    let result = if number > 0 {
        if number % 2 == 0 {
            "positive even"
        } else {
            "positive odd"
        }
    } else {
        "non-positive"
    };
    
    println!("{}, {}, {}", category, classify(number), result);
}

loop：无限循环与 break 返回值

loop 是 Rust 中最基础的循环结构，它创建一个无限循环，直到遇到 break 语句。与其他语言的 while(true) 不同，loop 明确表达了"无限循环"的意图，编译器也能更好地理解和优化这种模式。

loop 的独特之处在于它可以通过 break 返回值，这使得 loop 也能成为表达式的一部分。这个特性在实现重试逻辑、状态机或需要在循环中计算结果的场景中特别有用。你可以在循环中进行复杂的计算或条件判断，最终通过 break 携带计算结果跳出循环。

从设计角度看，loop 配合 break 返回值体现了 Rust 对"一切皆表达式"理念的坚持。即使是看似纯粹的控制流结构，也能优雅地融入表达式系统。这种设计使得代码更加紧凑，避免了在循环外部声明临时变量来传递结果。

fn loop_with_break_value() {
    let mut counter = 0;
    
    // loop 返回值
    let result = loop {
        counter += 1;
        
        if counter == 10 {
            break counter * 2;
        }
    };
    println!("Result from loop: {}", result);
    
    // 实际应用：重试机制
    let mut attempts = 0;
    let connection = loop {
        attempts += 1;
        
        match try_connect() {
            Ok(conn) => break conn,
            Err(_) if attempts < 3 => {
                println!("Retry attempt {}", attempts);
                continue;
            }
            Err(e) => panic!("Failed after 3 attempts: {:?}", e),
        }
    };
    
    // 嵌套 loop 与标签
    'outer: loop {
        println!("Outer loop");
        
        loop {
            println!("Inner loop");
            break 'outer; // 跳出外层循环
        }
    }
}

fn try_connect() -> Result<String, ()> {
    Ok("connected".to_string())
}

while：条件循环的清晰表达

while 循环在条件为真时持续执行，它是最常见的条件循环形式。虽然 while 循环不能像 loop 那样返回值（它总是返回单元类型 ()），但它在表达"当条件满足时执行"的逻辑时更加直观和简洁。

while 循环的价值在于其语义的清晰性。当你使用 while 时，你明确告诉代码阅读者：这个循环有一个明确的终止条件。相比于 loop 配合 if 和 break，while 的条件检查前置在循环头部，使得循环的终止逻辑一目了然。

在实践中，选择 while 还是 loop 取决于具体场景。如果循环有清晰的终止条件且不需要返回值，while 是更好的选择。如果循环的终止逻辑复杂，或需要从循环中返回值，loop 配合 break 更加灵活。这种选择不仅影响代码的可读性，也反映了开发者对问题的理解深度。

fn while_loop_examples() {
    // 基础 while 循环
    let mut n = 0;
    while n < 5 {
        println!("n = {}", n);
        n += 1;
    }
    
    // while let：处理 Option 或 Result
    let mut stack = vec![1, 2, 3, 4, 5];
    while let Some(value) = stack.pop() {
        println!("Popped: {}", value);
    }
    
    // 实际应用：解析输入流
    let mut input = "abc123def456".chars().peekable();
    while let Some(&c) = input.peek() {
        if c.is_alphabetic() {
            input.next();
            print!("{}", c);
        } else {
            break;
        }
    }
    println!();
}

for：迭代器循环的优雅实现

for 循环是 Rust 中最常用的循环形式，它基于迭代器模式实现。与 C 风格的三段式 for 循环不同，Rust 的 for 循环遍历实现了 IntoIterator trait 的任何类型。这种设计不仅简化了语法，更重要的是它与 Rust 的所有权系统完美结合。

for 循环的强大之处在于它对所有权的精细控制。通过选择 for x in collection、for x in &collection 或 for x in &mut collection，我们可以精确控制是移动、不可变借用还是可变借用集合中的元素。这种显式性避免了许多常见的所有权错误，同时也使代码的意图更加清晰。

迭代器是 Rust 标准库的核心抽象之一，for 循环与迭代器的结合提供了强大而高效的数据处理能力。编译器能够对迭代器进行激进的优化，生成的代码性能往往与手写的索引循环相当甚至更好。同时，迭代器提供的 map、filter、fold 等方法使得数据转换和聚合操作可以用声明式的方式表达。

fn for_loop_patterns() {
    let numbers = vec![1, 2, 3, 4, 5];
    
    // 消耗所有权：移动
    // for n in numbers {
    //     println!("{}", n);
    // }
    // println!("{:?}", numbers); // 错误：numbers 已被移动
    
    // 不可变借用
    for n in &numbers {
        println!("{}", n);
    }
    println!("Numbers still available: {:?}", numbers);
    
    // 可变借用
    let mut numbers = vec![1, 2, 3];
    for n in &mut numbers {
        *n *= 2;
    }
    println!("Doubled: {:?}", numbers);
    
    // 带索引的遍历
    for (index, value) in numbers.iter().enumerate() {
        println!("Index {}: {}", index, value);
    }
    
    // 范围迭代
    for i in 0..5 {
        println!("Range: {}", i);
    }
    
    // 反向迭代
    for i in (0..5).rev() {
        println!("Reversed: {}", i);
    }
}

// 迭代器链式操作
fn iterator_chaining() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    let result: i32 = numbers
        .iter()
        .filter(|&x| x % 2 == 0)
        .map(|&x| x * x)
        .sum();
    
    println!("Sum of squares of even numbers: {}", result);
}

循环控制：break 与 continue

break 和 continue 是控制循环流程的两个关键字。break 用于立即退出循环，continue 用于跳过当前迭代直接进入下一次迭代。在嵌套循环中，可以使用标签（label）来指定 break 或 continue 作用于哪一层循环。

循环标签是 Rust 提供的一个精巧特性，它解决了嵌套循环中跳转控制的难题。通过在循环前加上 'label: 标记，我们可以明确指定 break 'label 或 continue 'label 的目标，避免了使用额外的标志变量或复杂的条件判断。这种机制在实现复杂的搜索算法或状态机时特别有用。

模式匹配与控制流的结合

虽然 match 表达式本身不是传统意义上的控制流结构，但它在 Rust 中扮演着至关重要的角色。match 提供了比 if-else 链更强大的分支逻辑，通过模式匹配可以同时检查值和解构数据。编译器的完整性检查确保我们处理了所有可能的情况，这在编译时就消除了许多潜在的运行时错误。

if let 和 while let 是 match 的语法糖，专门用于只关心一种模式的场景。它们使得代码更加简洁，避免了为单一模式编写完整的 match 表达式。这种设计体现了 Rust 对人体工程学的重视——既提供强大的功能，也提供便捷的快捷方式。

总结

Rust 的控制流设计将传统的控制结构提升到了新的高度。通过将控制流设计为表达式、与所有权系统深度整合、提供丰富的迭代器抽象，Rust 在保持代码清晰性的同时提供了强大的表达能力和安全保证。理解这些控制流结构的深层机制，是编写地道 Rust 代码的基础，也是充分利用语言特性的关键。