青少年编程与数学 02-019 Rust 编程基础 09课题、流程控制

课题摘要:
在 Rust 编程中，控制流是程序执行逻辑的核心部分。Rust 提供了多种控制流工具，包括条件语句（if、match）、循环语句（loop、while、for）以及表达式（return、break、continue）。这些工具可以帮助你控制程序的执行路径，实现复杂的逻辑。

关键词：控制流、条件语句、循环语句、流程控制

---

一、条件语句

在 Rust 中，if 语句是一种条件语句，用于根据条件的真假来执行不同的代码块。它在 Rust 中的语法和功能与其他编程语言中的 if 语句类似，但也有其独特之处，尤其是在表达式和类型方面。

1. 基本语法

Rust 中的 if 语句的基本语法如下：

if 条件 {// 条件为 true 时执行的代码块
} else if 另一个条件 {// 另一个条件为 true 时执行的代码块
} else {// 所有条件都不满足时执行的代码块
}

• 条件：必须是一个布尔表达式，即其值为 true 或 false。
• 代码块：每个条件分支都有一个代码块，用大括号 {} 包裹。
• else 和 else if：else if 用于处理多个条件，else 是可选的，用于处理所有条件都不满足的情况。

2. 示例

以下是一个简单的 if 语句示例：

fn main() {let number = 6;if number % 4 == 0 {println!("number is divisible by 4");} else if number % 3 == 0 {println!("number is divisible by 3");} else if number % 2 == 0 {println!("number is divisible by 2");} else {println!("number is not divisible by 4, 3, or 2");}
}

在这个例子中：

• number % 4 == 0 是第一个条件，如果为 true，则执行第一个代码块。
• 如果第一个条件为 false，则检查 number % 3 == 0。
• 如果第二个条件也为 false，则检查 number % 2 == 0。
• 如果所有条件都不满足，则执行 else 分支。

3. if 语句作为表达式

在 Rust 中，if 语句不仅仅是一个控制流语句，它本身也是一个表达式。这意味着 if 语句可以返回一个值，这个值可以被赋值给变量。

示例

fn main() {let condition = true;let number = if condition { 5 } else { 6 };println!("The value of number is: {}", number);
}

在这个例子中：

• if condition { 5 } else { 6 } 是一个表达式。
• 如果 condition 为 true，则表达式的值为 5；否则为 6。
• 这个值被赋值给变量 number。

4. 类型要求

由于 if 语句是一个表达式，因此它的每个分支必须返回相同类型的值。否则，编译器会报错。

错误示例

fn main() {let condition = true;let number = if condition { 5 } else { "six" }; // 错误：类型不匹配
}

在这个例子中，if 分支返回一个整数 5，而 else 分支返回一个字符串 "six"，这会导致编译错误，因为 Rust 要求 if 表达式的每个分支返回相同类型的值。

正确示例

fn main() {let condition = true;let number = if condition { 5 } else { 6 }; // 正确：返回值类型相同
}

5. 无 else 分支的情况

如果 if 语句没有 else 分支，那么它的返回值类型必须是 ()（空元组），即没有返回值。

示例

fn main() {let condition = true;let number = if condition {5}; // 正确：没有 else 分支，返回值类型为 i32println!("The value of number is: {}", number);
}

但如果 if 表达式没有 else 分支且没有返回值，则其类型为 ()：

fn main() {let condition = false;let number = if condition {println!("Condition is true");}; // 正确：没有返回值，类型为 ()println!("The value of number is: {:?}", number);
}

6. 嵌套 if 语句

if 语句可以嵌套使用，即在一个 if 语句的代码块中再包含一个 if 语句。

示例

fn main() {let number = 10;if number > 5 {println!("number is greater than 5");if number % 2 == 0 {println!("number is even");} else {println!("number is odd");}} else {println!("number is not greater than 5");}
}

7. 小结

Rust 中的 if 语句是一种强大的控制流工具，它不仅可以用于条件分支，还可以作为表达式返回值。以下是一些关键点：

• if 语句的条件必须是布尔表达式。
• 每个分支的代码块用大括号 {} 包裹。
• if 语句可以有多个 else if 分支和一个 else 分支。
• if 语句本身是一个表达式，其每个分支必须返回相同类型的值。
• 如果没有 else 分支且没有返回值，则 if 表达式的类型为 ()。

通过合理使用 if 语句，可以实现复杂的逻辑控制，同时保持代码的清晰和可读性。

二、循环语句

在 Rust 中，循环语句是控制程序流程的重要工具，用于重复执行某段代码，直到满足特定条件为止。Rust 提供了多种循环语句，包括 loop、while 和 for 循环。每种循环都有其独特的用途和语法特点。以下是对 Rust 中循环语句的详细解析。

1. loop 循环

loop 是 Rust 中最基础的循环语句。它会无限循环，直到遇到 break 或 return 语句为止。

基本语法

loop {// 循环体代码
}

示例

以下是一个简单的 loop 循环示例，用于计算 1 到 10 的累加和：

fn main() {let mut sum = 0;let mut i = 1;loop {sum += i;i += 1;if i > 10 {break; // 当 i 大于 10 时退出循环}}println!("The sum is {}", sum); // 输出：The sum is 55
}

特点

• loop 是一个无限循环，不会自动终止。
• 必须在循环体中使用 break 或其他条件语句来控制退出循环。
• loop 可以返回一个值，通过 break 语句可以将值返回给循环的调用者。

返回值示例

fn main() {let result = loop {let mut i = 0;while i < 5 {i += 1;if i == 3 {break i * 2; // 返回值为 6}}};println!("The result is {}", result); // 输出：The result is 6
}

2. while 循环

while 循环会在条件为 true 时重复执行代码块，直到条件变为 false。

基本语法

while 条件 {// 循环体代码
}

示例

以下是一个 while 循环的示例，用于计算 1 到 10 的累加和：

fn main() {let mut sum = 0;let mut i = 1;while i <= 10 {sum += i;i += 1;}println!("The sum is {}", sum); // 输出：The sum is 55
}

特点

• while 循环的条件在每次循环开始时进行检查。
• 如果条件为 false，循环体将不会执行。
• while 循环不会返回值。

while let 循环

while let 是一种特殊的语法，用于处理 Option 或 Result 类型的值。它会在模式匹配成功时重复执行代码块，直到模式匹配失败。

示例

fn main() {let mut stack = vec![1, 2, 3];while let Some(top) = stack.pop() {println!("{}", top); // 依次输出 3, 2, 1}
}

在这个例子中，stack.pop() 返回一个 Option<i32>，当栈不为空时，while let 会匹配 Some(top)，并执行循环体代码；当栈为空时，pop() 返回 None，循环终止。

3. for 循环

for 循环是 Rust 中最常用的循环语句，用于遍历集合（如数组、向量、范围等）中的元素。

基本语法

for 变量 in 集合 {// 循环体代码
}

示例

以下是一个 for 循环的示例，用于遍历数组中的元素：

fn main() {let arr = [10, 20, 30, 40, 50];for element in arr {println!("{}", element); // 依次输出 10, 20, 30, 40, 50}
}

遍历范围

for 循环也可以用于遍历范围。Rust 提供了两种范围语法：

• a..b：表示从 a 到 b（不包括 b）的范围。
• a..=b：表示从 a 到 b（包括 b）的范围。

示例

fn main() {// 遍历 1 到 5（不包括 5）for i in 1..5 {println!("{}", i); // 依次输出 1, 2, 3, 4}// 遍历 1 到 5（包括 5）for i in 1..=5 {println!("{}", i); // 依次输出 1, 2, 3, 4, 5}
}

遍历可迭代对象

for 循环可以用于任何实现了 IntoIterator 特性的对象。例如，可以遍历字符串中的字符：

fn main() {let name = "Kimi";for c in name.chars() {println!("{}", c); // 依次输出 K, i, m, i}
}

带索引的遍历

如果需要在遍历时获取元素的索引，可以使用 enumerate() 方法：

fn main() {let arr = [10, 20, 30, 40, 50];for (index, element) in arr.iter().enumerate() {println!("Element at index {}: {}", index, element);}
}

输出：

Element at index 0: 10
Element at index 1: 20
Element at index 2: 30
Element at index 3: 40
Element at index 4: 50

循环控制语句

在循环中，可以使用以下控制语句：

• break：退出当前循环。
• continue：跳过当前循环的剩余部分，进入下一次迭代。

示例

fn main() {for i in 1..10 {if i % 2 == 0 {continue; // 跳过偶数}if i > 5 {break; // 退出循环}println!("{}", i); // 输出：1, 3, 5}
}

4. 小结

Rust 提供了多种循环语句，每种循环都有其独特的用途：

• loop：无限循环，适合需要手动控制退出条件的场景。
• while：条件循环，适合在条件满足时重复执行代码。
• for：遍历循环，适合遍历集合中的元素。

通过合理使用这些循环语句，可以实现复杂的逻辑控制，同时保持代码的清晰和可读性。

三、模式匹配（match）语句

在 Rust 中，match 语句是一种强大的控制流工具，用于根据某个值的模式进行分支选择。它类似于其他语言中的 switch 或 case 语句，但功能更为强大和灵活。match 不仅可以匹配字面值，还可以匹配结构体、枚举、元组等复杂数据类型，并且可以提取数据结构中的值用于进一步操作。

1. 基本语法

match 语句的基本语法如下：

match 表达式 {模式1 => 表达式1,模式2 => 表达式2,...模式N => 表达式N,
}

• 表达式：match 语句的第一个参数是一个表达式，它的值将被用来与各个模式进行匹配。
• 模式：每个分支的模式用于匹配表达式的值。如果匹配成功，则执行对应的分支。
• 表达式：每个分支的表达式是匹配成功后执行的代码块。最后一个分支通常是一个通配符 _，用于匹配所有其他未被前面模式匹配的值。

2. 示例

以下是一个简单的 match 示例，用于匹配一个整数并输出不同的信息：

fn main() {let number = 3;match number {1 => println!("One"),2 => println!("Two"),3 => println!("Three"),_ => println!("Something else"), // 通配符，匹配所有其他值}
}

在这个例子中：

• number 的值为 3，与第三个模式 3 匹配，因此输出 "Three"。
• 如果 number 的值不是 1、2 或 3，则匹配到最后一个模式 _，输出 "Something else"。

3. 模式匹配的特点

3.1 穷尽性（Exhaustiveness）

match 语句要求所有可能的值都被覆盖，否则编译器会报错。如果某些值没有被显式匹配，必须使用通配符 _ 来覆盖所有剩余的情况。

错误示例

fn main() {let number = 3;match number {1 => println!("One"),2 => println!("Two"),// 缺少对其他值的匹配，编译器会报错}
}

正确示例

fn main() {let number = 3;match number {1 => println!("One"),2 => println!("Two"),_ => println!("Something else"), // 通配符覆盖所有其他值}
}

3.2 非绑定性（Non-binding）

如果某个模式匹配成功，但没有绑定变量，那么该模式不会捕获任何值。

示例

fn main() {let number = 3;match number {1 => println!("One"),2 => println!("Two"),_ => println!("Something else"),}
}

在这个例子中，1 和 2 是字面值模式，它们不会捕获任何变量。

3.3 绑定变量

在模式中可以使用变量来捕获值，这些变量在匹配成功后可以在对应的表达式中使用。

示例

fn main() {let number = 3;match number {1 => println!("One"),2 => println!("Two"),num => println!("The number is {}", num), // 捕获变量}
}

在这个例子中，num 是一个变量，它捕获了 number 的值，并在匹配成功后可以在表达式中使用。

3.4 多个模式

可以使用 | 符号来匹配多个值。

示例

fn main() {let number = 3;match number {1 | 2 => println!("One or Two"),3 => println!("Three"),_ => println!("Something else"),}
}

在这个例子中，1 | 2 表示匹配 1 或 2。

3.5 范围匹配

可以使用范围匹配来匹配一个值是否在某个范围内。

示例

fn main() {let number = 3;match number {1..=5 => println!("Number is between 1 and 5 inclusive"),_ => println!("Number is outside the range"),}
}

在这个例子中，1..=5 表示匹配 1 到 5（包括 5）的范围。

4. 匹配枚举

match 语句非常适合用于匹配枚举类型。枚举的每个变体都可以作为一个模式。

示例

enum Message {Quit,Move { x: i32, y: i32 },Write(String),ChangeColor(i32, i32, i32),
}fn main() {let msg = Message::Write(String::from("Hello"));match msg {Message::Quit => {println!("The Quit variant has no data to destructure.");}Message::Move { x, y } => {println!("Move in the x direction {} and in the y direction {}", x, y);}Message::Write(text) => {println!("Text message: {}", text);}Message::ChangeColor(r, g, b) => {println!("Change the color to red {}, green {}, and blue {}", r, g, b);}}
}

在这个例子中：

• Message::Quit 没有数据，直接匹配。
• Message::Move { x, y } 匹配并提取 x 和 y。
• Message::Write(text) 匹配并提取 text。
• Message::ChangeColor(r, g, b) 匹配并提取 r、g 和 b。

5. 匹配结构体

match 语句也可以用于匹配结构体。结构体的字段可以通过模式匹配来提取。

示例

struct Point {x: i32,y: i32,
}fn main() {let p = Point { x: 0, y: 7 };match p {Point { x, y: 0 } => println!("On the x axis at {}", x),Point { x: 0, y } => println!("On the y axis at {}", y),Point { x, y } => println!("On neither axis: ({}, {})", x, y),}
}

在这个例子中：

• Point { x, y: 0 } 匹配 y 为 0 的情况。
• Point { x: 0, y } 匹配 x 为 0 的情况。
• Point { x, y } 匹配其他所有情况。

6. 匹配元组

match 语句也可以用于匹配元组。元组的每个元素可以通过模式匹配来提取。

示例

fn main() {let pair = (2, -2);match pair {(x, y) if x > 0 && y > 0 => println!("Both positive"),(x, y) if x < 0 && y < 0 => println!("Both negative"),(x, y) if x > 0 && y < 0 => println!("x is positive and y is negative"),(x, y) if x < 0 && y > 0 => println!("x is negative and y is positive"),_ => println!("One or both are zero"),}
}

在这个例子中：

• (x, y) if x > 0 && y > 0 匹配 x 和 y 都为正数的情况。
• (x, y) if x < 0 && y < 0 匹配 x 和 y 都为负数的情况。
• 其他情况通过通配符 _ 匹配。

7. 匹配中的守卫（Guard）

在 match 的模式中可以使用守卫（guard），即在模式后面添加一个条件表达式，只有当条件为 true 时，该模式才会匹配成功。

示例

fn main() {let number = 3;match number {x if x > 0 => println!("Number is positive"),x if x < 0 => println!("Number is negative"),_ => println!("Number is zero"),}
}

在这个例子中：

• x if x > 0 匹配 x 为正数的情况。
• x if x < 0 匹配 x 为负数的情况。
• _ 匹配其他情况（即 x 为 0）。

8. 小结

match 是 Rust 中一种非常强大和灵活的控制流工具，适用于多种场景：

• 匹配字面值、变量、范围等简单类型。
• 匹配枚举、结构体、元组等复杂数据类型。
• 使用守卫来添加额外的匹配条件。

match 语句要求穷尽所有可能的值，这有助于避免逻辑漏洞。通过合理使用 match，可以实现清晰、高效的分支逻辑。

四、控制流程表达式

在 Rust 中，控制流表达式（如 return、break 和 continue）用于在程序执行过程中改变正常的流程。这些表达式在循环、函数以及其他控制结构中非常有用，能够帮助开发者实现复杂的逻辑控制。以下是对 Rust 中这些控制流表达式的详细解析。

1. return 表达式

return 用于从函数中提前返回一个值。它可以在函数体的任何位置使用，一旦执行 return，函数的执行将立即终止，并返回指定的值。

基本语法

fn function_name() -> 返回类型 {// 函数体return 表达式;
}

示例

以下是一个简单的函数，使用 return 提前返回值：

fn main() {let result = calculate(10);println!("The result is {}", result); // 输出：The result is 100
}fn calculate(x: i32) -> i32 {if x > 5 {return x * 10; // 提前返回值}x + 1
}

在这个例子中：

• 如果 x > 5，则执行 return x * 10，函数立即返回 x * 10 的值。
• 如果 x <= 5，则执行函数的最后一条语句 x + 1，并返回其值。

注意事项

• return 只能在函数中使用，不能在函数外部使用。
• 如果函数没有返回值（即返回类型为 ()），可以使用 return; 提前返回。

2. break 表达式

break 用于退出循环。它可以在 loop、while 和 for 循环中使用。break 可以带有一个值，这个值可以被返回给循环的调用者。

基本语法

loop {// 循环体if 条件 {break [值];}
}

示例

以下是一个使用 break 的 loop 循环示例：

fn main() {let mut counter = 0;let result = loop {counter += 1;if counter == 10 {break counter * 2; // 带值退出循环}};println!("The result is {}", result); // 输出：The result is 20
}

在这个例子中：

• 循环会一直执行，直到 counter 等于 10。
• 当 counter == 10 时，执行 break counter * 2，循环退出，并返回 counter * 2 的值。

在 while 和 for 循环中使用 break

break 也可以用于 while 和 for 循环，但不能带值返回。

示例

fn main() {let mut counter = 0;while counter < 10 {counter += 1;if counter == 5 {break; // 退出 while 循环}}println!("The counter is {}", counter); // 输出：The counter is 5
}

3. continue 表达式

continue 用于跳过当前循环的剩余部分，并直接进入下一次迭代。它可以在 loop、while 和 for 循环中使用。

基本语法

loop {// 循环体if 条件 {continue;}// 跳过部分
}

示例

以下是一个使用 continue 的 for 循环示例：

fn main() {for i in 1..10 {if i % 2 == 0 {continue; // 跳过偶数}println!("{}", i); // 输出奇数}
}

在这个例子中：

• 循环会遍历 1 到 9 的范围。
• 如果 i 是偶数（i % 2 == 0），执行 continue，跳过当前迭代的剩余部分。
• 如果 i 是奇数，则打印 i。

输出

1
3
5
7
9

4. 小结

Rust 提供了以下控制流表达式，用于在程序中实现复杂的逻辑控制：

• return：从函数中提前返回一个值。
• break：退出循环，可以带值返回（仅在 loop 中）。
• continue：跳过当前循环的剩余部分，进入下一次迭代。

这些表达式在循环和函数中非常有用，能够帮助开发者实现高效的逻辑控制。合理使用这些表达式可以提高代码的可读性和可维护性。

五、综合示例

以下是根据文中内容编写的 Rust 示例程序，展示了流程控制的各种用法，包括条件语句、循环语句、模式匹配和控制流表达式：

fn main() {// 条件语句示例condition_example();// 循环语句示例loop_example();while_example();for_example();// 模式匹配示例match_example();// 控制流表达式示例control_flow_example();
}// 条件语句示例
fn condition_example() {println!("条件语句示例：");let number = 6;if number % 4 == 0 {println!("number is divisible by 4");} else if number % 3 == 0 {println!("number is divisible by 3");} else if number % 2 == 0 {println!("number is divisible by 2");} else {println!("number is not divisible by 4, 3, or 2");}let condition = true;let number = if condition { 5 } else { 6 };println!("The value of number is: {}", number);
}// 循环语句示例
fn loop_example() {println!("\nloop循环示例：");let mut sum = 0;let mut i = 1;loop {sum += i;i += 1;if i > 10 {break; // 当 i 大于 10 时退出循环}}println!("The sum is {}", sum); // 输出：The sum is 55
}fn while_example() {println!("\nwhile循环示例：");let mut sum = 0;let mut i = 1;while i <= 10 {sum += i;i += 1;}println!("The sum is {}", sum); // 输出：The sum is 55
}fn for_example() {println!("\nfor循环示例：");let arr = [10, 20, 30, 40, 50];for element in arr {println!("{}", element); // 依次输出 10, 20, 30, 40, 50}println!("\n遍历范围示例：");for i in 1..=5 {println!("{}", i); // 依次输出 1, 2, 3, 4, 5}println!("\n带索引的遍历示例：");for (index, element) in arr.iter().enumerate() {println!("Element at index {}: {}", index, element);}
}// 模式匹配示例
fn match_example() {println!("\n模式匹配示例：");let number = 3;match number {1 => println!("One"),2 => println!("Two"),3 => println!("Three"),_ => println!("Something else"), // 通配符，匹配所有其他值}println!("\n匹配枚举示例：");#[allow(dead_code)]enum Message {Quit,Move { x: i32, y: i32 },Write(String),ChangeColor(i32, i32, i32),}let msg = Message::Write(String::from("Hello"));match msg {Message::Quit => {println!("The Quit variant has no data to destructure.");}Message::Move { x, y } => {println!("Move in the x direction {} and in the y direction {}", x, y);}Message::Write(text) => {println!("Text message: {}", text);}Message::ChangeColor(r, g, b) => {println!("Change the color to red {}, green {}, and blue {}", r, g, b);}}println!("\n匹配结构体示例：");struct Point {x: i32,y: i32,}let p = Point { x: 0, y: 7 };match p {Point { x, y: 0 } => println!("On the x axis at {}", x),Point { x: 0, y } => println!("On the y axis at {}", y),Point { x, y } => println!("On neither axis: ({}, {})", x, y),}println!("\n匹配元组示例：");let pair = (2, -2);match pair {(x, y) if x > 0 && y > 0 => println!("Both positive"),(x, y) if x < 0 && y < 0 => println!("Both negative"),(x, y) if x > 0 && y < 0 => println!("x is positive and y is negative"),(x, y) if x < 0 && y > 0 => println!("x is negative and y is positive"),_ => println!("One or both are zero"),}
}// 控制流表达式示例
fn control_flow_example() {println!("\n控制流表达式示例：");println!("return表达式示例：");let result = calculate(10);println!("The result is {}", result); // 输出：The result is 100println!("\nbreak表达式示例：");let mut counter = 0;let result = loop {counter += 1;if counter == 10 {break counter * 2; // 带值退出循环}};println!("The result is {}", result); // 输出：The result is 20println!("\ncontinue表达式示例：");for i in 1..10 {if i % 2 == 0 {continue; // 跳过偶数}println!("{}", i); // 输出奇数}
}fn calculate(x: i32) -> i32 {if x > 5 {return x * 10; // 提前返回值}x + 1
}

运行结果

条件语句示例：
number is divisible by 3
The value of number is: 5loop循环示例：
while循环示例：
for循环示例：
10
20
30
40
遍历范围示例：
1
2
3
4
5带索引的遍历示例：
Element at index 0: 10
Element at index 1: 20
Element at index 2: 30
Element at index 3: 40
Element at index 4: 50模式匹配示例：
Three匹配枚举示例：
Text message: Hello匹配结构体示例：
On the y axis at 7匹配元组示例：
x is positive and y is negative控制流表达式示例：
return表达式示例：
The result is 100break表达式示例：
The result is 20continue表达式示例：
1
3
5
7
9

示例程序说明

1. 条件语句示例：

   使用 if 语句判断一个数字是否能被 4、3 或 2 整除。

   使用 if 语句作为表达式，根据条件返回不同的值。

2. 循环语句示例：

   使用 loop 循环计算 1 到 10 的累加和。

   使用 while 循环计算 1 到 10 的累加和。

   使用 for 循环遍历数组、范围和字符串中的字符，并展示带索引的遍历。

3. 模式匹配示例：
   使用 match 语句匹配整数、枚举、结构体和元组。

   展示了模式匹配中的守卫（guard）的用法。

4. 控制流表达式示例：
   使用 return 提前从函数返回值。

   使用 break 退出循环，并带值返回。

   使用 continue 跳过当前循环的剩余部分。

运行此程序将展示 Rust 中流程控制的各种用法，帮助你更好地理解和掌握这些工具。

总结

Rust 提供了丰富的控制流工具，包括条件语句（if、match）、循环语句（loop、while、for）以及控制流表达式（return、break、continue）。这些工具可以帮助你实现复杂的逻辑，控制程序的执行路径。通过合理使用这些工具，你可以编写出清晰、高效的 Rust 代码。