while let 循环匹配 ​

什么是 while let ​

while let 是 while 和模式匹配的结合体。它在每次迭代前尝试将一个值与模式匹配,匹配成功就执行循环体,匹配失败就退出循环。最常见的用法是配合 Option 类型——当值是 Some 时继续循环,遇到 None 时停止。

rust
fn main() {
    let mut stack = vec![1, 2, 3, 4, 5];

    // pop() 返回 Option<i32>
    // 每次匹配 Some(value),匹配到 None 时退出
    while let Some(top) = stack.pop() {
        println!("弹出:{}", top);
    }
    // 输出:5, 4, 3, 2, 1(后进先出)

    println!("栈已空,长度:{}", stack.len());  // 0
}

基本语法 ​

while let 的语法是:while let 模式 = 表达式 { 循环体 }

rust
fn main() {
    // 匹配 Option
    let mut values = vec![Some(10), Some(20), None, Some(40)];
    values.reverse();

    // 注意:这里 pop 返回 Option<Option<i32>>
    // 外层 Some 表示 vec 还有元素,内层才是实际值
    while let Some(Some(val)) = values.pop() {
        println!("值:{}", val);
    }
    // 输出:10, 20
    // 遇到 None 时外层 Some(None) 不匹配 Some(Some(val)),退出

    // 匹配 Result
    let inputs = vec!["42", "hello", "100"];
    let mut iter = inputs.iter();
    while let Some(s) = iter.next() {
        if let Ok(num) = s.parse::<i32>() {
            println!("解析成功:{}", num);
        } else {
            println!("解析失败:{}", s);
        }
    }
}

while let 与迭代器 ​

while let 配合迭代器的 next() 方法可以手动遍历集合。虽然 for 循环更简洁,但 while let 在需要更精细控制时很有用。

rust
fn main() {
    let names = vec!["张三", "李四", "王五", "赵六"];

    // for 循环(推荐的标准写法)
    for name in &names {
        println!("for: {}", name);
    }

    // while let + next()(等价写法)
    let mut iter = names.iter();
    while let Some(name) = iter.next() {
        println!("while let: {}", name);
    }

    // while let 的优势:可以在循环中"偷看"下一个元素
    let numbers = vec![1, 2, 3, 4, 5];
    let mut iter = numbers.iter().peekable();
    while let Some(&current) = iter.next() {
        // peek 查看下一个元素但不消耗
        if let Some(&&next) = iter.peek() {
            println!("{} -> {} (差值:{})", current, next, next - current);
        } else {
            println!("{} 是最后一个", current);
        }
    }
}

while let 处理队列和栈 ​

rust
use std::collections::VecDeque;

fn main() {
    // 用 VecDeque 模拟消息队列
    let mut queue: VecDeque<String> = VecDeque::new();
    queue.push_back(String::from("任务A"));
    queue.push_back(String::from("任务B"));
    queue.push_back(String::from("任务C"));

    // pop_front 从队列头部取出(先进先出)
    println!("处理队列:");
    while let Some(task) = queue.pop_front() {
        println!("  处理:{}", task);
    }

    // 用 Vec 模拟栈
    let mut undo_stack: Vec<String> = Vec::new();
    undo_stack.push(String::from("输入文字"));
    undo_stack.push(String::from("加粗"));
    undo_stack.push(String::from("改颜色"));

    // pop 从栈顶取出(后进先出)
    println!("\n撤销操作:");
    while let Some(action) = undo_stack.pop() {
        println!("  撤销:{}", action);
    }
}

while let 与枚举 ​

rust
enum Token {
    Number(f64),
    Plus,
    Minus,
    End,
}

fn main() {
    let mut tokens = vec![
        Token::Number(3.0),
        Token::Plus,
        Token::Number(5.0),
        Token::Minus,
        Token::Number(2.0),
        Token::End,
    ];
    tokens.reverse();  // 反转以便 pop 按顺序取出

    // 持续取出 token 直到遇到 End 或者没有更多 token
    let mut result = 0.0;
    let mut operation: Option<fn(f64, f64) -> f64> = None;

    while let Some(token) = tokens.pop() {
        match token {
            Token::Number(n) => {
                if let Some(op) = operation {
                    result = op(result, n);
                    operation = None;
                } else {
                    result = n;
                }
            }
            Token::Plus => {
                operation = Some(|a, b| a + b);
            }
            Token::Minus => {
                operation = Some(|a, b| a - b);
            }
            Token::End => {
                println!("遇到结束标记");
                break;
            }
        }
    }
    println!("计算结果:{}", result);  // 3 + 5 - 2 = 6
}

基本示例 ​

逐行解析简单的配置格式:

rust
fn parse_config(input: &str) -> Vec<(String, String)> {
    let mut result = Vec::new();
    let mut lines = input.lines();

    // while let 逐行处理
    while let Some(line) = lines.next() {
        // 跳过空行和注释
        let trimmed = line.trim();
        if trimmed.is_empty() || trimmed.starts_with('#') {
            continue;
        }

        // 尝试按 = 分割
        if let Some(pos) = trimmed.find('=') {
            let key = trimmed[..pos].trim().to_string();
            let value = trimmed[pos + 1..].trim().to_string();
            result.push((key, value));
        }
    }

    result
}

fn main() {
    let config_text = r#"
# 数据库配置
host = localhost
port = 5432
database = myapp

# 应用配置
debug = true
max_connections = 100
    "#;

    let config = parse_config(config_text);
    println!("解析到 {} 个配置项:", config.len());
    for (key, value) in &config {
        println!("  {} = {}", key, value);
    }
}

常见问题 ​

问题一:while let 和 for 有什么区别?

对比项while letfor
控制粒度手动调用 next(),可以跳步、回看自动迭代,每次取一个
模式匹配可以匹配复杂模式只能绑定元素
提前退出breakbreak
适用场景需要更细致的迭代控制标准的遍历

问题二:while let 和 loop + match 有什么区别?

while let 是 loop + match 的语法糖。两者等价:

rust
fn main() {
    let mut v = vec![1, 2, 3];

    // while let 写法
    while let Some(val) = v.pop() {
        println!("{}", val);
    }

    // 等价的 loop + match 写法
    let mut v2 = vec![4, 5, 6];
    loop {
        match v2.pop() {
            Some(val) => println!("{}", val),
            None => break,
        }
    }
}

问题三:while let 可以有 else 吗?

不可以。while let 没有 else 分支。模式不匹配时直接退出循环。如果需要在退出时做什么,把代码放在循环后面就行。

问题四:while let 会消耗被匹配值的所有权吗?

取决于表达式。stack.pop() 会消耗元素的所有权(从 Vec 中移除)。iter.next() 返回引用,不消耗原集合的所有权。

适用场景 ​

  • 消耗式处理:从 Vec、VecDeque 中逐个取出并处理元素
  • 迭代器手动控制:需要在迭代过程中跳步、回看或条件性消耗
  • 消息/事件队列:持续从队列中取出消息直到队列为空
  • 流式解析:逐个 token 或逐行处理输入数据
  • 栈操作:用 pop() 逐个弹出栈元素

注意事项 ​

  • while let 在模式不匹配时退出,不会 panic
  • 标准的集合遍历优先用 for,while let 用于需要更细致控制的场景
  • while let 没有 else 分支
  • 注意 Vec::pop() 是从末尾取出,如果需要从头取用 VecDeque::pop_front()
  • while let 可以嵌套模式匹配(如 Some(Some(val)))
  • 循环体内仍然可以用 break 和 continue

总结 ​

while let 是模式匹配和循环的结合,每次迭代前尝试匹配一个模式,成功就执行循环体,失败就退出。它最常见的用法是配合返回 Option 的方法(如 pop()、next())进行消耗式遍历。相比 for 循环,while let 提供了更细致的迭代控制能力;相比 loop + match,while let 写法更简洁。在标准遍历场景下优先用 for,需要手动控制迭代过程或处理非标准的 Option 返回值时用 while let。