《Rust快速入门》2. 控制流

January 18, 2025

控制流：条件判断、循环和模式匹配

在编程中，控制流是程序执行的顺序。通过控制流，我们可以根据条件执行不同的代码块，重复执行某些代码，或者根据不同的模式匹配执行不同的逻辑。本文将详细介绍条件判断（if、else if、else）、循环（loop、while、for）以及模式匹配（match）的使用，并提供完整的代码示例和详尽的指导过程。

1. 条件判断：`if`、`else if` 和 `else`

条件判断是编程中最基本的控制流结构之一。它允许我们根据条件的真假来执行不同的代码块。在 Rust 中，条件判断主要通过 if、else if 和 else 来实现。

1.1 `if` 语句

if 语句用于判断一个条件是否为真。如果条件为真，则执行 if 块中的代码；否则，跳过 if 块。

1
2
3
4
5
6
7


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 条件为真，则执行对应的代码块。

1
2
3
4
5
6
7
8
9


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 条件都不满足时，执行对应的代码块。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


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 语句。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


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 语句退出循环。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


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 循环会在条件为真时重复执行代码块。当条件不再为真时，循环结束。

1
2
3
4
5
6
7
8


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 循环通常用于迭代数组、向量或范围。

1
2
3
4
5
6
7


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 循环还可以用于遍历一个范围。

1
2
3
4
5


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 表达式将一个值与一系列模式进行比较，并执行与第一个匹配的模式对应的代码块。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


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 表达式常用于处理枚举类型。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


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 表达式可以将匹配的值绑定到变量上，以便在代码块中使用。

1
2
3
4
5
6
7
8


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 条件）来进一步过滤匹配的模式。

1
2
3
4
5
6
7
8
9


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. 综合示例

下面是一个综合示例，展示了条件判断、循环和模式匹配的结合使用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


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 程序的基础。

控制流：条件判断、循环和模式匹配

1. 条件判断：if、else if 和 else

1.1 if 语句

1.2 else if 语句

1.3 else 语句

1.4 嵌套 if 语句

2. 循环：loop、while 和 for

2.1 loop 循环

2.2 while 循环

2.3 for 循环

2.4 for 循环与范围

2.5 loop、while 和 for 的选择

3. 模式匹配：match 表达式

3.1 基本 match 表达式

3.2 match 表达式与枚举

3.3 match 表达式与绑定

3.4 match 表达式与守卫

4. 综合示例

5. 总结

1. 条件判断：`if`、`else if` 和 `else`

1.1 `if` 语句

1.2 `else if` 语句

1.3 `else` 语句

1.4 嵌套 `if` 语句

2. 循环：`loop`、`while` 和 `for`

2.1 `loop` 循环

2.2 `while` 循环

2.3 `for` 循环

2.4 `for` 循环与范围

2.5 `loop`、`while` 和 `for` 的选择

3. 模式匹配：`match` 表达式

3.1 基本 `match` 表达式

3.2 `match` 表达式与枚举

3.3 `match` 表达式与绑定

3.4 `match` 表达式与守卫