🦀 深入理解 Rust 控制流（if / loop / while / for）的工程实践

Rust 的控制流看似朴素，却蕴含了所有权、借用检查、零成本抽象等语义。真正写到生产代码，你会遇到：**如何优雅地返回值？何时选 loop？for 会不会“吃掉”集合？怎样避免分支预测失败？**本文从语义 → 编译期行为 → 实战模式，逐步展开。

---

一、四种控制流的语义速览

结构	典型用法	是否返回值	常见陷阱	适用场景
if/else	条件分支	✅ 作为表达式返回最后一个分支的值	分支类型必须一致；容易产生嵌套	小逻辑分支、表达式化返回
loop	无限循环 + 显式 break	✅ break value 返回值	忘记 break、可读性	状态机、重试/backoff、一次入口多出口
while	条件循环（先判断）	❌ 自身无返回值	容易写“忙等”；条件复杂时可读性差	有明确继续条件的循环
for	迭代器驱动循环	❌ 自身无返回值	into_iter 可能移动集合	遍历集合/流式处理（惰性/零拷贝）

记忆法：需要“表达式式”返回值时优先 if、loop { break v }；遍历集合选 for；条件循环选 while。

---

二、if 是表达式：让分支更“函数式”

Rust 的 if 可直接作为表达式返回值，且所有分支最终类型必须一致（或能统一到同一类型）。

fn price(level: u8) -> u32 {
    let base = 100;
    let factor = if level >= 10 { 3 } else if level >= 5 { 2 } else { 1 };
    base * factor
}

工程启示：

• 让 if 承担“选择 + 产生值”，减少“先声明、后赋值”的可变绑定。
• 分支里如有早退逻辑，考虑把局部逻辑抽函数，降低嵌套。

---

三、loop 的威力：break value、多出口与标签跳转

1）break value：把循环当成“可控的表达式块”

fn first_ok(nums: &[i32]) -> Option<i32> {
    let v = loop {
        for &n in nums {
            if n > 42 { break Some(n); }
        }
        break None;
    };
    v
}

loop 允许 break expr，整个 loop 表达式的值就是 expr。这在复杂初始化、早停搜索、错误恢复中非常实用。

2）标签跳转：在嵌套循环中准确退出

fn find_xy(grid: &[Vec<u8>]) -> Option<(usize, usize)> {
    'outer: for (i, row) in grid.iter().enumerate() {
        for (j, &cell) in row.iter().enumerate() {
            if cell == b'X' {
                // … 某些检查
                if j + 1 < row.len() && row[j + 1] == b'Y' {
                    break 'outer Some((i, j));
                }
            }
        }
    }
}

经验：标签精确退出比用“哨兵变量 + break”更清晰；嵌套不深时可读性极佳。

3）重试 / 退避（backoff）模式

use std::{thread, time::Duration};

fn retry<F, T, E>(mut f: F, max_retry: u32) -> Result<T, E>
where
    F: FnMut() -> Result<T, E>,
{
    let mut backoff = 10; // ms
    let res = loop {
        match f() {
            ok @ Ok(_) => break ok,
            Err(e) if backoff < 160 => {
                thread::sleep(Duration::from_millis(backoff));
                backoff *= 2;
                continue;
            }
            err @ Err(_) => break err,
        }
    };
    res
}

loop 在“单入口、多出口”需求下是最自然的表达方式。

---

四、while 与 while let：条件循环与解构

1）while

fn wait_until_ready<F: Fn() -> bool>(ready: F) {
    let mut spins = 0;
    while !ready() && spins < 100 {
        std::hint::spin_loop(); // 避免忙等发热
        spins += 1;
    }
}

2）while let：边匹配边消费

fn drain_stack(stack: &mut Vec<i32>) -> i32 {
    let mut sum = 0;
    while let Some(v) = stack.pop() {
        sum += v;
    }
    sum
}

经验：while let 适合“Option/Result/迭代器”式数据源的渐进消费；比手写 match + break 更紧凑。

---

五、for 的所有权语义：iter / iter_mut / into_iter

Rust 的 for 基于 IntoIterator。不同进入方式所有权不同：

let mut v = vec![1,2,3];

// 不可变借用：不消费 v
for x in v.iter() { /* &i32 */ }

// 可变借用：原地修改
for x in v.iter_mut() { *x *= 2; }

// 移动所有权：v 被消费，之后不可再用
for x in v.into_iter() { /* i32 */ }

小坑：for x in v { ... } 等价于 for x in v.into_iter()，会移动所有权。若需保留 v，显式写 &v / v.iter()。

迭代器链与零成本

for 循环遍历迭代器时，内联与单态化通常能消掉中间层（零成本抽象）。但闭包捕获、动态分发、逃逸可能限制优化，详见下一节。

---

六、性能与可读性的取舍：一些“硬核”经验

1）能表达为“值”的就别写副作用

// ✗：副作用 + 可变绑定
let factor;
if more { factor = 3 } else { factor = 2 }
price * factor

// ✓：表达式式
price * if more { 3 } else { 2 }

2）loop 与 while 的选择

• 循环体内部可能在多处“带值退出” → loop { break value }
• 有明确继续条件 → while/while let
• 读流/集合 → for

3）减少分支预测失败

热路径中的布尔条件如不均衡，考虑：

• 先判断极常见分支；
• 使用 likely/unlikely hint（目前常以 if condition { /* hot */ } else { /* cold */ } + 结构化优化代替；宏或 #[cold] 放在冷路径函数上）。

4）少造中间集合，合并遍历

// ✗：collect 产生中间 Vec
let r: i64 = nums.iter().map(|x| x*x).filter(|x| x%2==0).cloned().collect::<Vec<_>>().iter().sum();

// ✓：单次遍历、无中间集合
let r: i64 = nums.iter().map(|x| x*x).filter(|x| x%2==0).sum();

5）闭包开销与内联

• 简短闭包多会被内联；跨模块/动态分发会削弱优化。
• 热循环里可把关键逻辑提到 #[inline(always)] 的小函数（谨慎使用，防止代码尺寸膨胀）。

---

七、实战：解析器状态机（loop + 标签 + 带值 break）

以下示例实现一个简化的十进制无符号整数解析器（遇错即返回错误位置），演示 loop 带值返回 与 标签退出：

#[derive(Debug, PartialEq)]
enum ParseErr { Empty, InvalidChar { idx: usize } }

fn parse_u64(s: &str) -> Result<u64, ParseErr> {
    let bytes = s.as_bytes();
    if bytes.is_empty() { return Err(ParseErr::Empty); }

    let mut acc: u64 = 0;
    let mut i = 0usize;

    'scan: loop {
        if i >= bytes.len() { break 'scan Ok(acc); }
        let b = bytes[i];
        match b {
            b'0'..=b'9' => {
                let digit = (b - b'0') as u64;
                // 溢出检查（避免 UB）
                acc = acc.checked_mul(10)
                         .and_then(|v| v.checked_add(digit))
                         .ok_or(ParseErr::InvalidChar { idx: i })?;
                i += 1;
            }
            _ => break 'scan Err(ParseErr::InvalidChar { idx: i }),
        }
    }
}

要点：

• loop + break Ok(acc) / break Err(..)：自然地把“扫描直到结束或出错”的流程表达为值。
• 无多余标志变量；错误路径清晰。

---

八、实战：for 的所有权坑位与优化写法

场景：遍历一批任务，成功的收集起来、失败的记日志

#[derive(Debug)]
struct Task(u32);

fn run(task: &Task) -> Result<u32, String> {
    if task.0 % 7 == 0 { Err(format!("bad {}", task.0)) } else { Ok(task.0 * 2) }
}

fn process(mut tasks: Vec<Task>) -> (Vec<u32>, Vec<String>) {
    let mut ok = Vec::with_capacity(tasks.len());
    let mut errs = Vec::new();

    // 不移动任务容器，只借用
    for t in tasks.iter() {
        match run(t) {
            Ok(v) => ok.push(v),
            Err(e) => errs.push(e),
        }
    }

    // 仍然可以复用 tasks，例如再次分派：
    tasks.retain(|t| t.0 % 7 == 0); // 保留失败的做二次处理
    (ok, errs)
}

经验：默认用 iter()，除非你确实要消费容器（如转移所有权、避免拷贝）。

---

九、思维导图（文本版）

Rust 控制流
├─ if（表达式）
│  ├─ 分支统一类型
│  └─ 让逻辑“产值”而非副作用
├─ loop（无限循环）
│  ├─ break value（表达式式返回）
│  ├─ 标签跳转（嵌套退出）
│  └─ 重试/状态机/一次入口多出口
├─ while / while let
│  ├─ 先判断条件
│  └─ 渐进消费（Option/Result/迭代器）
└─ for（迭代器驱动）
   ├─ iter / iter_mut / into_iter（所有权）
   ├─ 零成本抽象（内联与单态化）
   └─ 少造中间集合、合并遍历

---

十、Checklist：把控“正确性—性能—可维护性”

• 能表达为值就别用可变中间变量（if/loop { break v }）。
• 嵌套循环优先用标签精确退出。
• 遍历集合默认 iter()；需要修改再 iter_mut()；确认消费才 into_iter()。
• 使用 while let 渐进消费 Option/Result/Iterator。
• 热路径减少分支预测失败：先写常见分支；冷路径独立函数。
• 避免中间 collect()；尽量单次遍历完成聚合。
• 对溢出、边界、错误做显式处理（checked_* / ? / Result）。

---

结语

Rust 的控制流设计“简洁但不简单”。把控制流写成“能产生值的表达式”、用 loop 优雅表达“重试/状态机”、在 for 中正确处理所有权，能把可读性与性能同时拉满。建议在团队代码中形成统一约定（如默认 iter()、热路径优先分支、loop 仅在需要带值退出时使用），让控制流既稳又快。