loop 无限循环
什么是 loop
loop 是 Rust 中最简单的循环结构——它会无条件地反复执行循环体,直到遇到 break 才会退出。和 while true 不同,loop 明确表达了"这是一个无限循环"的意图,而且编译器知道它永远不会自行终止,可以做更好的类型推断。
loop 最独特的能力是 break 可以携带值,让循环变成一个能返回结果的表达式。
fn main() {
let mut count = 0;
// 基本的 loop,用 break 退出
loop {
count += 1;
if count >= 5 {
break;
}
}
println!("循环了 {} 次", count);
}loop 返回值
这是 loop 区别于 while 和 for 的关键特性——break 可以携带一个值,作为整个 loop 表达式的返回值。
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
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
}实际使用场景
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 的对比
| 对比项 | loop | while true |
|---|---|---|
| 语义 | 明确的无限循环 | 条件恰好永远为真 |
| break 返回值 | 支持 | 不支持 |
| 编译器提示 | 无警告 | Clippy 建议改成 loop |
| 类型推断 | 更好(编译器知道必须 break) | 一般 |
| 社区约定 | 推荐 | 不推荐 |
fn main() {
// 推荐:用 loop
let value = loop {
break 42;
};
println!("{}", value);
// 不推荐:while true 不能返回值
// while true {
// break; // 不能 break 42
// }
}基本示例
用 loop 实现二分查找:
// 二分查找:在有序数组中查找目标值,返回索引
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 带值,有的不带,就会编译错误。
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——语义更清晰,编译器优化更好,而且支持返回值。