控制流：条件判断、循环和模式匹配
在编程中，控制流是程序执行的顺序。通过控制流，我们可以根据条件执行不同的代码块，重复执行某些代码，或者根据不同的模式匹配执行不同的逻辑。本文将详细介绍条件判断（if、else if、else）、循环（loop、while、for）以及模式匹配（match）的使用，并提供完整的代码示例和详尽的指导过程。
1. 条件判断：if、else if 和 else
条件判断是编程中最基本的控制流结构之一。它允许我们根据条件的真假来执行不同的代码块。在 Rust 中，条件判断主要通过 if、else if 和 else 来实现。
1.1 if 语句
if 语句用于判断一个条件是否为真。如果条件为真，则执行 if 块中的代码；否则，跳过 if 块。
fn main() {
let number = 7;
if number < 10 {
println!("The number is less than 10");
}
}
解释：
let number = 7;定义了一个变量number并赋值为7。if number < 10 { ... }判断number是否小于10，如果条件为真，则执行println!语句。
1.2 else if 语句
else if 语句用于在 if 条件不满足时，检查另一个条件。如果 else if 条件为真，则执行对应的代码块。
fn main() {
let number = 15;
if number < 10 {
println!("The number is less than 10");
} else if number < 20 {
println!("The number is between 10 and 20");
}
}
解释：
let number = 15;定义了一个变量number并赋值为15。if number < 10 { ... }判断number是否小于10，如果条件为真，则执行第一个println!语句。else if number < 20 { ... }在if条件不满足时，判断number是否小于20，如果条件为真，则执行第二个println!语句。
1.3 else 语句
else 语句用于在所有 if 和 else if 条件都不满足时，执行对应的代码块。
fn main() {
let number = 25;
if number < 10 {
println!("The number is less than 10");
} else if number < 20 {
println!("The number is between 10 and 20");
} else {
println!("The number is 20 or greater");
}
}
解释：
let number = 25;定义了一个变量number并赋值为25。if number < 10 { ... }判断number是否小于10，如果条件为真，则执行第一个println!语句。else if number < 20 { ... }在if条件不满足时，判断number是否小于20，如果条件为真，则执行第二个println!语句。else { ... }在所有条件都不满足时，执行第三个println!语句。
1.4 嵌套 if 语句
if 语句可以嵌套使用，即在 if 块中再使用 if 语句。
fn main() {
let number = 15;
if number < 20 {
if number < 10 {
println!("The number is less than 10");
} else {
println!("The number is between 10 and 20");
}
} else {
println!("The number is 20 or greater");
}
}
解释：
let number = 15;定义了一个变量number并赋值为15。if number < 20 { ... }判断number是否小于20，如果条件为真，则进入嵌套的if语句。- 在嵌套的
if语句中，if number < 10 { ... }判断number是否小于10，如果条件为真，则执行第一个println!语句；否则，执行else块中的println!语句。 - 如果
number不小于20，则执行外层的else块中的println!语句。
2. 循环：loop、while 和 for
循环是编程中用于重复执行某段代码的控制流结构。Rust 提供了三种主要的循环结构：loop、while 和 for。
2.1 loop 循环
loop 循环会无限重复执行代码块，直到显式地使用 break 语句退出循环。
fn main() {
let mut count = 0;
loop {
println!("Count: {}", count);
count += 1;
if count == 5 {
break;
}
}
}
解释：
let mut count = 0;定义了一个可变变量count并初始化为0。loop { ... }开始一个无限循环。println!("Count: {}", count);打印当前的count值。count += 1;每次循环将count增加1。if count == 5 { break; }当count等于5时，使用break语句退出循环。
2.2 while 循环
while 循环会在条件为真时重复执行代码块。当条件不再为真时，循环结束。
fn main() {
let mut count = 0;
while count < 5 {
println!("Count: {}", count);
count += 1;
}
}
解释：
let mut count = 0;定义了一个可变变量count并初始化为0。while count < 5 { ... }当count小于5时，重复执行循环体。println!("Count: {}", count);打印当前的count值。count += 1;每次循环将count增加1。- 当
count不再小于5时，循环结束。
2.3 for 循环
for 循环用于遍历集合或范围中的元素。for 循环通常用于迭代数组、向量或范围。
fn main() {
let numbers = [1, 2, 3, 4, 5];
for number in numbers.iter() {
println!("Number: {}", number);
}
}
解释：
let numbers = [1, 2, 3, 4, 5];定义了一个数组numbers。for number in numbers.iter() { ... }使用for循环遍历数组numbers中的每个元素。println!("Number: {}", number);打印当前的元素值。
2.4 for 循环与范围
for 循环还可以用于遍历一个范围。
fn main() {
for number in 1..6 {
println!("Number: {}", number);
}
}
解释：
for number in 1..6 { ... }使用for循环遍历范围1..6（包含1，不包含6）。println!("Number: {}", number);打印当前的数字。
2.5 loop、while 和 for 的选择
- 使用
loop当需要无限循环，直到某个条件满足时退出。 - 使用
while当需要在条件为真时重复执行代码块。 - 使用
for当需要遍历集合或范围中的元素。
3. 模式匹配：match 表达式
模式匹配是 Rust 中一种强大的控制流工具，它允许我们根据不同的模式执行不同的代码块。match 表达式是 Rust 中实现模式匹配的主要方式。
3.1 基本 match 表达式
match 表达式将一个值与一系列模式进行比较，并执行与第一个匹配的模式对应的代码块。
fn main() {
let number = 3;
match number {
1 => println!("One"),
2 => println!("Two"),
3 => println!("Three"),
_ => println!("Other"),
}
}
解释：
let number = 3;定义了一个变量number并赋值为3。match number { ... }将number与一系列模式进行比较。1 => println!("One"),如果number等于1，则执行println!("One")。2 => println!("Two"),如果number等于2，则执行println!("Two")。3 => println!("Three"),如果number等于3，则执行println!("Three")。_ => println!("Other"),如果number不匹配任何前面的模式，则执行println!("Other")。_是一个通配符模式，匹配任何值。
3.2 match 表达式与枚举
match 表达式常用于处理枚举类型。
enum Direction {
Up,
Down,
Left,
Right,
}
fn main() {
let direction = Direction::Up;
match direction {
Direction::Up => println!("Going up"),
Direction::Down => println!("Going down"),
Direction::Left => println!("Going left"),
Direction::Right => println!("Going right"),
}
}
解释：
enum Direction { ... }定义了一个枚举类型Direction，包含四个变体：Up、Down、Left和Right。let direction = Direction::Up;定义了一个变量direction并赋值为Direction::Up。match direction { ... }将direction与枚举的变体进行比较，并执行匹配的代码块。
3.3 match 表达式与绑定
match 表达式可以将匹配的值绑定到变量上，以便在代码块中使用。
fn main() {
let number = 5;
match number {
n @ 1..=5 => println!("Number between 1 and 5: {}", n),
_ => println!("Other"),
}
}
解释：
let number = 5;定义了一个变量number并赋值为5。match number { ... }将number与模式进行比较。n @ 1..=5 => println!("Number between 1 and 5: {}", n),如果number在1到5之间（包括1和5），则将number绑定到变量n上，并执行println!语句。_ => println!("Other"),如果number不匹配前面的模式，则执行println!("Other")。
3.4 match 表达式与守卫
match 表达式可以使用守卫（if 条件）来进一步过滤匹配的模式。
fn main() {
let number = 7;
match number {
n if n < 5 => println!("Less than 5: {}", n),
n if n > 5 => println!("Greater than 5: {}", n),
_ => println!("Equal to 5"),
}
}
解释：
let number = 7;定义了一个变量number并赋值为7。match number { ... }将number与模式进行比较。n if n < 5 => println!("Less than 5: {}", n),如果number小于5，则执行println!语句。n if n > 5 => println!("Greater than 5: {}", n),如果number大于5，则执行println!语句。_ => println!("Equal to 5"),如果number等于5，则执行println!语句。
4. 综合示例
下面是一个综合示例，展示了条件判断、循环和模式匹配的结合使用。
fn main() {
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
for number in numbers.iter() {
match number {
n if n % 2 == 0 => println!("{} is even", n),
n if n % 2 != 0 => println!("{} is odd", n),
_ => (),
}
}
}
解释：
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];定义了一个数组numbers。for number in numbers.iter() { ... }使用for循环遍历数组numbers中的每个元素。match number { ... }将number与模式进行比较。n if n % 2 == 0 => println!("{} is even", n),如果number是偶数，则执行println!语句。n if n % 2 != 0 => println!("{} is odd", n),如果number是奇数，则执行println!语句。_ => (),如果number不匹配前面的模式，则不执行任何操作。
5. 总结
本文详细介绍了 Rust 中的控制流结构，包括条件判断（if、else if、else）、循环（loop、while、for）以及模式匹配（match）。通过丰富的代码示例和详尽的解释，读者可以掌握这些控制流结构的基本用法和适用场景。掌握这些控制流结构是编写高效、可读性强的 Rust 程序的基础。
继续阅读
探索更多技术文章
浏览归档，发现更多关于系统设计、工具链和工程实践的内容。