跳到主要内容 Rust 控制流核心：条件、循环与模式匹配 | 极客日志
Rust 算法
Rust 控制流核心：条件、循环与模式匹配 Rust 语言中的控制流机制。涵盖基础及高级条件表达式（if/else）、三种循环结构（loop、while、for）的用法与性能考量。详细讲解了强大的模式匹配工具 match 表达式，以及 if let 和 while let 的简洁语法。最后提供了代码可读性优化与错误处理的最佳实践，帮助开发者编写安全高效的 Rust 程序。
协议工匠 发布于 2026/3/29 更新于 2026/4/18
第 4 章 控制流
4.1 条件表达式 if/else
4.1.1 基础条件表达式
在 Rust 中，条件表达式是程序决策的基础。与其他语言不同，Rust 的 if 表达式总是返回一个值，这使得它们更加灵活和强大。
fn basic_conditionals () {
println! ("=== 基础条件表达式 ===" );
let number = 7 ;
if number < 5 {
println! ("条件为真" );
} else {
println! ("条件为假" );
}
let score = 85 ;
if score >= 90 {
println! ("优秀" );
} else if score >= 80 {
println! ("良好" );
} else if score >= 70 {
println! ("中等" );
} else if score >= 60 {
println! ("及格" );
} else {
println! (微信扫一扫，关注极客日志 微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
相关免费在线工具 加密/解密文本 使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
Base64 字符串编码/解码 将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器 将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
Markdown转HTML 将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
HTML转Markdown 将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
JSON 压缩 通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
"不及格"
let
condition
true
let
result
if
"真分支的值"
else
"假分支的值"
println!
"if 表达式结果：{}"
let
number
6
let
is_even
if
2
0
"偶数"
else
"奇数"
println!
"{} 是 {}"
let
x
10
let
y
20
let
comparison
if
"x 大于 y"
else
if
"x 小于 y"
else
"x 等于 y"
println!
"比较结果：{}"
let
flag
true
if
println!
"标志为真"
if
println!
"标志为假"
4.1.2 高级条件表达式模式 fn advanced_conditional_patterns () {
println! ("=== 高级条件表达式模式 ===" );
fn process_user (age: Option <u32 >, has_consent: bool ) -> String {
if age.is_none () {
return "年龄信息缺失" .to_string ();
}
let age = age.unwrap ();
if !has_consent {
return "需要用户同意" .to_string ();
}
if age < 18 {
return "用户未成年" .to_string ();
}
"处理成功" .to_string ()
}
println! ("守卫条件示例：{}" , process_user (Some (20 ), true ));
let mut counter = 0 ;
let max_attempts = 3 ;
while let true = { counter += 1 ; counter <= max_attempts } {
println! ("尝试 {} of {}" , counter, max_attempts);
}
let is_weekday = true ;
let is_holiday = false ;
let has_meeting = true ;
let workload = 75 ;
let should_work_from_home = (is_weekday && !is_holiday) && (has_meeting || workload > 80 );
println! ("应该在家办公：{}" , should_work_from_home);
let config = Some ("production" );
if let Some (env) = config {
println! ("运行在 {} 环境" , env);
}
let point = (5 , 10 );
if let (x, y) = point {
if x > 0 && y > 0 {
println! ("点 ({}, {}) 在第一象限" , x, y);
}
}
fn parse_number (s: &str ) -> Result <i32 , String > {
if s.is_empty () {
return Err ("字符串为空" .to_string ());
}
if !s.chars ().all (|c| c.is_ascii_digit ()) {
return Err ("包含非数字字符" .to_string ());
}
Ok (s.parse ().unwrap ())
}
match parse_number ("123" ) {
Ok (num) => println! ("解析成功：{}" , num),
Err (e) => println! ("解析失败：{}" , e),
}
#[cfg(debug_assertions)]
{
println! ("这是调试构建" );
}
#[cfg(not(debug_assertions))]
{
println! ("这是发布构建" );
}
#[cfg(feature = "logging" )]
{
println! ("日志特性已启用" );
}
}
4.2 循环：loop、while、for
4.2.1 loop 循环深度解析 loop 循环是 Rust 中最基本的循环结构，它会无限循环直到显式中断。
fn loop_deep_dive () {
println! ("=== loop 循环深度解析 ===" );
let mut counter = 0 ;
loop {
counter += 1 ;
println! ("循环次数：{}" , counter);
if counter >= 5 {
break ;
}
}
let result = loop {
counter += 1 ;
if counter >= 10 {
break counter * 2 ;
}
};
println! ("loop 返回值：{}" , result);
'outer : loop {
println! ("进入外部循环" );
let mut inner_counter = 0 ;
'inner : loop {
inner_counter += 1 ;
println! (" 内部循环：{}" , inner_counter);
if inner_counter >= 3 {
break 'inner ;
}
}
counter += 1 ;
if counter >= 2 {
break 'outer ;
}
}
let mut values = vec! [1 , 2 , 3 , 4 , 5 ].into_iter ();
loop {
match values.next () {
Some (value) => {
println! ("处理值：{}" , value);
if value == 3 {
println! ("找到目标值，继续处理..." );
continue ;
}
}
None => {
println! ("没有更多值" );
break ;
}
}
}
let mut number = 0 ;
loop {
number += 1 ;
if number % 2 == 0 {
continue ;
}
println! ("奇数：{}" , number);
if number >= 9 {
break ;
}
}
complex_loop_control ();
}
4.2.2 while 循环深度解析 fn while_loop_deep_dive () {
println! ("=== while 循环深度解析 ===" );
let mut counter = 0 ;
while counter < 5 {
println! ("计数器：{}" , counter);
counter += 1 ;
}
let mut stack = Vec ::new ();
stack.push (1 );
stack.push (2 );
stack.push (3 );
println! ("栈内容:" );
while let Some (top) = stack.pop () {
println! ("弹出：{}" , top);
}
let mut x = 100 ;
while x > 0 {
x /= 2 ;
if x == 0 {
break ;
}
println! ("x = {}" , x);
}
process_user_input_simulation ();
let numbers = [1 , 2 , 3 , 4 , 5 ];
let mut iter = numbers.iter ();
while let Some (&number) = iter.next () {
if number == 3 {
println! ("找到 3，跳过剩余" );
break ;
}
println! ("处理数字：{}" , number);
}
let mut remaining_time = 10 ;
while remaining_time > 0 {
println! ("倒计时：{}秒" , remaining_time);
remaining_time -= 1 ;
std::thread::sleep (std::time::Duration::from_millis (100 ));
}
println! ("时间到！" );
}
4.2.3 for 循环深度解析 for 循环是 Rust 中最常用的循环结构，主要用于迭代集合。
fn for_loop_deep_dive () {
println! ("=== for 循环深度解析 ===" );
println! ("范围迭代:" );
for i in 0 ..5 {
println! ("i = {}" , i);
}
println! ("包含范围:" );
for i in 0 ..=5 {
println! ("i = {}" , i);
}
let numbers = [10 , 20 , 30 , 40 , 50 ];
println! ("数组迭代:" );
for number in numbers {
println! ("数字：{}" , number);
}
let names = vec! ["Alice" , "Bob" , "Charlie" ];
println! ("向量迭代:" );
for name in &names {
println! ("名字：{}" , name);
}
println! ("带索引迭代:" );
for (index, name) in names.iter ().enumerate () {
println! ("索引 {}: {}" , index, name);
}
let text = "Hello, 世界!" ;
println! ("字符迭代:" );
for (i, ch) in text.chars ().enumerate () {
println! ("位置 {}: '{}' (U+{:04X})" , i, ch, ch as u32 );
}
println! ("字节迭代:" );
for byte in text.bytes () {
println! ("字节：0x{:02X}" , byte);
}
use std::collections::HashMap;
let mut scores = HashMap::new ();
scores.insert ("Alice" , 100 );
scores.insert ("Bob" , 85 );
scores.insert ("Charlie" , 92 );
println! ("哈希映射迭代:" );
for (name, score) in &scores {
println! ("{}: {}" , name, score);
}
println! ("反向迭代:" );
for i in (0 ..5 ).rev () {
println! ("i = {}" , i);
}
println! ("步长迭代:" );
for i in (0 ..20 ).step_by (3 ) {
println! ("i = {}" , i);
}
println! ("嵌套循环:" );
for i in 0 ..3 {
for j in 0 ..3 {
println! ("({}, {})" , i, j);
}
}
advanced_for_patterns ();
}
4.3 模式匹配与 match 表达式
4.3.1 match 表达式基础 match 是 Rust 中最强大的控制流工具之一，提供全面的模式匹配能力。
fn match_expression_basics () {
println! ("=== match 表达式基础 ===" );
let number = 13 ;
match number {
1 => println! ("一" ),
2 | 3 | 5 | 7 | 11 => println! ("质数" ),
13 ..=19 => println! ("青少年数字" ),
_ => println! ("其他数字" ),
}
let number = 5 ;
let description = match number {
1 => "一" ,
2 => "二" ,
3 => "三" ,
_ => "很多" ,
};
println! ("数字 {} 是 {}" , number, description);
let flag = true ;
match flag {
true => println! ("真" ),
false => println! ("假" ),
}
let grade = 'A' ;
match grade {
'A' | 'B' | 'C' => println! ("及格" ),
'D' => println! ("勉强及格" ),
'F' => println! ("不及格" ),
_ => println! ("无效成绩" ),
}
let language = "Rust" ;
match language {
"Rust" => println! ("系统编程语言" ),
"Python" => println! ("脚本语言" ),
"Java" => println! ("企业级语言" ),
_ => println! ("其他语言" ),
}
let boolean = true ;
match boolean {
true => println! ("真" ),
false => println! ("假" ),
}
let value = 42 ;
match value {
1 => println! ("一" ),
2 => println! ("二" ),
_ => (),
}
let age = 25 ;
match age {
0 ..=12 => println! ("儿童" ),
13 ..=19 => println! ("青少年" ),
20 ..=64 => println! ("成人" ),
_ => println! ("长者" ),
}
}
4.3.2 if let 和 while let if let 和 while let 提供了模式匹配的简洁语法。
fn if_let_while_let_patterns () {
println! ("=== if let 和 while let 模式 ===" );
let some_value = Some (5 );
match some_value {
Some (x) => println! ("值为：{}" , x),
None => (),
}
if let Some (x) = some_value {
println! ("值为：{}" , x);
}
let none_value : Option <i32 > = None ;
if let Some (x) = none_value {
println! ("有值：{}" , x);
} else {
println! ("没有值" );
}
let some_number = Some (10 );
if let Some (x) = some_number {
if x > 5 {
println! ("值 {} 大于 5" , x);
}
}
if let Some (x) = some_number && x > 5 {
println! ("值 {} 大于 5" , x);
}
enum Event {
Click { x: i32 , y: i32 },
KeyPress (char ),
}
let event = Event::Click { x: 100 , y: 200 };
if let Event ::Click { x, y } = event {
println! ("点击位置：({}, {})" , x, y);
}
let mut stack = Vec ::new ();
stack.push (1 );
stack.push (2 );
stack.push (3 );
println! ("使用 while let 弹出栈:" );
while let Some (top) = stack.pop () {
println! ("弹出：{}" , top);
}
let numbers = vec! [1 , 2 , 3 , 4 , 5 ];
let mut iter = numbers.iter ();
println! ("使用 while let 迭代:" );
while let Some (&number) = iter.next () {
println! ("数字：{}" , number);
}
let mut optional = Some (0 );
while let Some (i) = optional {
if i > 9 {
println! ("大于 9，退出" );
optional = None ;
} else {
println! ("`i` 是 `{:?}`，继续" , i);
optional = Some (i + 1 );
}
}
let config_max = Some (3u8 );
let max_value = if let Some (max) = config_max { max } else { 0u8 };
println! ("最大值：{}" , max_value);
let result : Result <i32 , &str > = Ok (42 );
if let Ok (value) = result {
println! ("成功：{}" , value);
}
if let Err (error) = result {
println! ("错误：{}" , error);
}
practical_if_let_examples ();
}
4.4 控制流最佳实践
4.4.1 代码可读性与维护性 fn readability_best_practices () {
println! ("=== 代码可读性最佳实践 ===" );
let user_age = 25 ;
let has_driving_license = true ;
if user_age >= 18 && has_driving_license {
println! ("可以驾驶" );
}
let a = 25 ;
let b = true ;
if a >= 18 && b {
println! ("可以驾驶" );
}
complex_nested_logic ();
refactored_complex_logic ();
fn process_user_data (name: Option <&str >, age: Option <u32 >) -> Result <String , String > {
let name = name.ok_or ("姓名缺失" )?;
let age = age.ok_or ("年龄缺失" )?;
if name.is_empty () {
return Err ("姓名为空" .to_string ());
}
if age < 18 {
return Err ("用户未成年" .to_string ());
}
Ok (format! ("用户 {} 年龄 {}" , name, age))
}
let temperature = 25 ;
let is_weekend = true ;
let has_plans = false ;
if temperature > 20 && temperature < 30 && is_weekend && !has_plans {
println! ("好天气，没安排，出门吧！" );
}
let good_weather = temperature > 20 && temperature < 30 ;
let free_time = is_weekend && !has_plans;
if good_weather && free_time {
println! ("好天气，没安排，出门吧！" );
}
enum TrafficLight {
Red,
Yellow,
Green,
}
let light = TrafficLight::Red;
match light {
TrafficLight::Red => println! ("停止" ),
TrafficLight::Yellow => println! ("准备" ),
TrafficLight::Green => println! ("通行" ),
}
let score = 85 ;
let grade = match score {
90 ..=100 => "优秀" ,
80 ..=89 => "良好" ,
70 ..=79 => "中等" ,
60 ..=69 => "及格" ,
_ => "不及格" ,
};
println! ("成绩等级：{}" , grade);
}
4.4.2 错误处理模式 fn error_handling_patterns () {
println! ("=== 错误处理模式 ===" );
fn parse_number (s: &str ) -> Result <i32 , String > {
s.parse ().map_err (|_| "解析失败" .to_string ())
}
let input = "42" ;
match parse_number (input) {
Ok (number) => println! ("解析成功：{}" , number),
Err (error) => println! ("解析失败：{}" , error),
}
fn process_data (data: &str ) -> Result <i32 , String > {
let num1 = parse_number (data)?;
let num2 = parse_number ("100" )?;
Ok (num1 + num2)
}
fn comprehensive_data_processing (input: &str ) -> Result <String , String > {
let number = input.parse::<i32 >().map_err (|_| "数字解析失败" .to_string ())?;
if number < 0 {
return Err ("数字不能为负" .to_string ());
}
if number > 1000 {
return Err ("数字太大" .to_string ());
}
Ok (format! ("处理后的数字：{}" , number * 2 ))
}
let result = comprehensive_data_processing ("5000" );
if let Err (error) = &result {
if error == "数字太大" {
println! ("数字超出范围，但可以继续处理" );
}
}
fn convert_errors () -> Result <(), String > {
let input = "not_a_number" ;
let _number : i32 = input.parse ().map_err (|e| format! ("解析错误：{}" , e))?;
Ok (())
}
fn find_user (name: &str ) -> Option <&str > {
if name == "admin" {
Some ("管理员用户" )
} else {
None
}
}
let user = find_user ("admin" );
match user {
Some (user_info) => println! ("找到用户：{}" , user_info),
None => println! ("用户不存在" ),
}
let user = find_user ("guest" ).unwrap_or ("默认用户" );
println! ("用户：{}" , user);
fn complex_operation () -> Result <i32 , String > {
Ok (42 )
}
let final_result = complex_operation ().and_then (|x| Ok (x * 2 )).and_then (|x| if x > 50 { Ok (x) } else { Err ("值太小" .to_string ()) });
match final_result {
Ok (value) => println! ("最终结果：{}" , value),
Err (error) => println! ("处理失败：{}" , error),
}
}
通过本章的全面学习，你已经深入掌握了 Rust 的控制流系统。从基础的条件表达式到复杂的模式匹配，从简单的循环到高级的迭代器模式，你现在应该能够编写出既安全又高效的 Rust 控制流代码。在下一章中，我们将深入探讨 Rust 最独特的特性：所有权系统。
