loop 无限循环 ​

什么是 loop ​

loop 是 Rust 中最简单的循环结构——它会无条件地反复执行循环体,直到遇到 break 才会退出。和 while true 不同,loop 明确表达了"这是一个无限循环"的意图,而且编译器知道它永远不会自行终止,可以做更好的类型推断。

loop 最独特的能力是 break 可以携带值,让循环变成一个能返回结果的表达式。

rust
fn main() {
    let mut count = 0;

    // 基本的 loop,用 break 退出
    loop {
        count += 1;
        if count >= 5 {
            break;
        }
    }
    println!("循环了 {} 次", count);
}

loop 返回值 ​

这是 loop 区别于 while 和 for 的关键特性——break 可以携带一个值,作为整个 loop 表达式的返回值。

rust
fn main() {
    let mut counter = 0;

    // loop 表达式通过 break 返回值
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;  // 返回 20
        }
    };
    println!("结果:{}", result);  // 20

    // 用 loop 实现"重试直到成功"
    let mut attempts = 0;
    let value = loop {
        attempts += 1;
        // 模拟可能失败的操作
        let success = attempts >= 3;
        if success {
            break format!("第 {} 次尝试成功", attempts);
        }
        println!("第 {} 次尝试失败,重试...", attempts);
    };
    println!("{}", value);
}

loop 与 break/continue ​

rust
fn main() {
    // break 退出循环
    let mut i = 0;
    loop {
        i += 1;
        if i > 10 {
            break;
        }
        print!("{} ", i);
    }
    println!();  // 1 2 3 4 5 6 7 8 9 10

    // continue 跳过当前迭代
    let mut j = 0;
    loop {
        j += 1;
        if j > 20 {
            break;
        }
        // 跳过不是 3 的倍数的数
        if j % 3 != 0 {
            continue;
        }
        print!("{} ", j);
    }
    println!();  // 3 6 9 12 15 18
}

实际使用场景 ​

rust
fn main() {
    // 场景一:输入验证循环
    // 模拟反复验证直到输入合法
    let inputs = vec!["abc", "-5", "0", "42"];
    let mut iter = inputs.iter();

    let valid_number = loop {
        let input = match iter.next() {
            Some(s) => s,
            None => break 0,  // 没有更多输入了
        };

        match input.parse::<i32>() {
            Ok(n) if n > 0 => break n,  // 找到正整数,退出
            Ok(n) => println!("'{}' 不是正数,重试", n),
            Err(_) => println!("'{}' 不是数字,重试", input),
        }
    };
    println!("有效输入:{}", valid_number);

    // 场景二:游戏主循环
    let mut frame = 0;
    loop {
        frame += 1;
        // 模拟游戏逻辑
        if frame > 5 {
            println!("游戏结束");
            break;
        }
        println!("渲染第 {} 帧", frame);
    }
}

loop 与 while true 的对比 ​

对比项loopwhile true
语义明确的无限循环条件恰好永远为真
break 返回值支持不支持
编译器提示无警告Clippy 建议改成 loop
类型推断更好(编译器知道必须 break)一般
社区约定推荐不推荐
rust
fn main() {
    // 推荐:用 loop
    let value = loop {
        break 42;
    };
    println!("{}", value);

    // 不推荐:while true 不能返回值
    // while true {
    //     break;  // 不能 break 42
    // }
}

基本示例 ​

用 loop 实现二分查找:

rust
// 二分查找:在有序数组中查找目标值,返回索引
fn binary_search(data: &[i32], target: i32) -> Option<usize> {
    let mut low = 0;
    let mut high = data.len();

    // loop + break 返回查找结果
    loop {
        if low >= high {
            break None;  // 没找到
        }

        let mid = low + (high - low) / 2;

        if data[mid] == target {
            break Some(mid);  // 找到了,返回索引
        } else if data[mid] < target {
            low = mid + 1;
        } else {
            high = mid;
        }
    }
}

// 用 loop 实现简单的状态机
fn process_sequence(data: &[i32]) -> (i32, i32) {
    let mut index = 0;
    let mut sum = 0;
    let mut max = i32::MIN;

    let result = loop {
        if index >= data.len() {
            break (sum, max);
        }

        let val = data[index];
        sum += val;
        if val > max {
            max = val;
        }
        index += 1;
    };

    result
}

fn main() {
    let sorted_data = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91];

    let targets = [23, 50, 2, 91, 100];
    for &target in &targets {
        match binary_search(&sorted_data, target) {
            Some(index) => println!("找到 {} 在索引 {}", target, index),
            None => println!("{} 不在数组中", target),
        }
    }

    println!();

    let data = [15, 42, 8, 23, 16, 4, 38];
    let (sum, max) = process_sequence(&data);
    println!("总和:{},最大值:{}", sum, max);
}

常见问题 ​

问题一:loop 什么时候比 while 好?

当你不需要在循环开头检查条件,而是在循环体内部根据复杂逻辑决定是否退出时,loop 更自然。另外,当你需要循环返回一个值时,只有 loop 能做到。

问题二:loop 中忘记写 break 会怎样?

程序会无限循环,永远不会退出。编译器不会警告你(因为无限循环在某些场景下是合理的,比如服务器主循环、嵌入式设备的主循环)。

问题三:break 返回值的类型需要一致吗?

所有 break 语句返回的值类型必须一致。如果有的 break 带值,有的不带,就会编译错误。

rust
fn main() {
    let x = loop {
        if true {
            break 42;     // i32
        }
        // break "hello";  // 编译错误:类型不匹配
        // break;          // 编译错误:expected i32, found ()
    };
    println!("{}", x);
}

问题四:loop 可以嵌套吗?

可以。嵌套的 loop 中,break 默认退出最内层循环。要退出外层循环需要用标签(break 'label),这在后面的章节会讲到。

适用场景 ​

  • 重试逻辑:反复尝试某个操作直到成功
  • 服务器主循环:持续监听和处理请求
  • 游戏主循环:每帧更新和渲染
  • 状态机:在循环中根据当前状态做不同处理
  • 交互式程序:读取用户输入并处理,直到用户选择退出
  • 需要返回值的循环:只有 loop 的 break 能携带值

注意事项 ​

  • loop 必须通过 break 退出,否则会无限循环
  • break 可以携带值,让 loop 成为返回值的表达式
  • 所有 break 语句的返回值类型必须一致
  • 嵌套循环中 break 默认退出最内层
  • 无限循环用 loop,不要用 while true
  • loop 中的 continue 会跳到下一次循环开头
  • 在嵌入式开发中,loop {} 常用作程序的主入口循环

总结 ​

loop 是 Rust 的无限循环结构,会不断执行循环体直到遇到 break。它和 while/for 最大的区别是 break 可以携带值,让整个 loop 成为一个能返回结果的表达式。这个特性非常适合"重试直到成功"的模式和需要在循环中计算并返回结果的场景。无限循环应该始终用 loop 而不是 while true——语义更清晰,编译器优化更好,而且支持返回值。