1149 字

6 分钟

study 2day pro

2025-11-03

rust

🦀 Rust 控制流 (进阶版教程)#

作者：xiaolin 适用范围：有一定 Rust 基础，想深入理解控制结构与表达式机制。

目录#

控制流概述
if 表达式
loop 循环
while 循环
for 循环
控制关键字：break / continue / return
标签循环（Labeled Loops）
match 模式匹配
if let / while let 表达式
控制流中的表达式特性
实践建议

🧭 控制流概述#

Rust 中所有控制结构（if、match、loop 等）都是 表达式，即都有返回值。

区别于 C / Go 语言的语句式风格，Rust 的控制流是 函数式表达式风格：

1
let number = if true { 100 } else { 200 };
2
println!("{}", number); // 输出 100

🧩 if 表达式#

基本用法#

1
let x = 10;
2
if x > 5 {
3
    println!("x 大于 5");
4
} else {
5
    println!("x 小于等于 5");
6
}

表达式返回值#

1
let result = if x % 2 == 0 { "even" } else { "odd" };
2
println!("x 是 {}", result);

⚠️ 注意：

if / else 分支的返回值类型必须一致。

❌ 错误示例：

1
let value = if true { 10 } else { "hello" }; // ❌ 类型不一致

🔁 loop 循环#

loop 表示无限循环，直到 break 被显式调用。

1
let mut count = 0;
2
loop {
3
    count += 1;
4
    if count == 3 {
5
        println!("退出循环");
6
        break;
7
    }
8
}

loop 的返回值#

Rust 的 loop 可以返回值！（高级特性）

1
let result = loop {
2
    let value = 42;
3
    break value * 2;
4
};
5

6
println!("结果: {}", result); // 84

⚙️ while 循环#

当条件为真时执行循环：

1
let mut n = 0;
2
while n < 5 {
3
    println!("n = {}", n);
4
    n += 1;
5
}

与 loop 相比，while 自动判断条件退出。

🔄 for 循环#

Rust 的 for 是基于 迭代器 的高级循环结构。

遍历区间#

1
for i in 0..5 {
2
    println!("i = {}", i);
3
}

0..5 表示 [0, 1, 2, 3, 4] 0..=5 表示 [0, 1, 2, 3, 4, 5]

遍历集合#

1
let arr = [10, 20, 30];
2
for val in arr.iter() {
3
    println!("val = {}", val);
4
}

遍历并索引#

1
for (i, val) in arr.iter().enumerate() {
2
    println!("第 {} 个值: {}", i, val);
3
}

🚪 控制关键字#

break#

终止当前循环。

1
for i in 0..10 {
2
    if i == 5 {
3
        break;
4
    }
5
    println!("i = {}", i);
6
}

continue#

跳过当前迭代，进入下一轮。

1
for i in 0..5 {
2
    if i == 2 {
3
        continue;
4
    }
5
    println!("i = {}", i);
6
}

return#

退出当前函数。

1
fn calc() -> i32 {
2
    for i in 0..10 {
3
        if i == 3 {
4
            return i * 10;
5
        }
6
    }
7
    0
8
}

🏷️ 标签循环#

Rust 支持多层循环时的 带标签跳出（非常强大）：

1
let mut outer = 0;
2

3
'outer_loop: loop {
4
    let mut inner = 0;
5

6
    loop {
7
        if inner == 2 {
8
            break; // 只跳出内层
9
        }
10
        if outer == 1 {
11
            break 'outer_loop; // 跳出外层循环
12
        }
13
        inner += 1;
14
    }
15

16
    outer += 1;
17
}
18

19
println!("外层结束: {}", outer);

🎯 match 模式匹配#

match 是 Rust 中比 switch 更强大的控制结构。

1
let status = 200;
2

3
match status {
4
    200 => println!("OK"),
5
    404 => println!("Not Found"),
6
    500 => println!("Server Error"),
7
    _ => println!("Unknown"),
8
}

模式匹配绑定变量#

1
let age = 20;
2

3
match age {
4
    0..=12 => println!("儿童"),
5
    13..=19 => println!("青少年"),
6
    20..=30 => println!("青年"),
7
    _ => println!("成年人"),
8
}

多分支合并#

1
match status {
2
    200 | 201 => println!("Success"),
3
    400 | 404 => println!("Client Error"),
4
    _ => println!("Other"),
5
}

🔍 if let / while let#

这两个语法是 match 的语法糖，用于匹配单个模式。

if let#

1
let some_value = Some(10);
2

3
if let Some(v) = some_value {
4
    println!("值为: {}", v);
5
} else {
6
    println!("为 None");
7
}

while let#

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

3
while let Some(top) = stack.pop() {
4
    println!("弹出: {}", top);
5
}

🧠 控制流中的表达式特性#

Rust 的所有控制语句都是 表达式（Expression），意味着可以直接用于赋值：

1
let grade = match 85 {
2
    90..=100 => "A",
3
    80..=89  => "B",
4
    70..=79  => "C",
5
    _ => "D",
6
};
7

8
println!("成绩等级: {}", grade);

🪄 实践建议#

场景	建议写法	理由
简单条件	`if`	清晰简洁
多条件枚举	`match`	可读性高
无限循环	`loop` + `break value`	支持返回值
嵌套循环	标签 + `break 'outer`	避免逻辑混乱
解构枚举	`if let` / `match`	Rust 最推荐模式

🧩 示例：综合应用#

1
fn main() {
2
    let mut n = 0;
3

4
    'counting: loop {
5
        println!("当前 n: {}", n);
6
        n += 1;
7

8
        if n == 3 {
9
            println!("跳过一次循环");
10
            continue;
11
        }
12

13
        match n {
14
            5 => {
15
                println!("达到 5，退出外层循环");
16
                break 'counting;
17
            },
18
            _ => println!("继续循环中..."),
19
        }
20
    }
21

22
    println!("循环结束，最终 n = {}", n);
23
}

输出：

1
当前 n: 0
2
继续循环中...
3
当前 n: 1
4
继续循环中...
5
当前 n: 2
6
跳过一次循环
7
当前 n: 3
8
继续循环中...
9
当前 n: 4
10
达到 5，退出外层循环
11
循环结束，最终 n = 5

✅ 总结#

控制结构	特点
`if` / `else`	表达式，有返回值
`loop`	无限循环，可返回值
`while`	条件循环
`for`	基于迭代器
`break / continue`	控制循环执行
`'label`	多层循环跳出
`match`	强大的模式匹配
`if let / while let`	match 简化形式