第4章 控制流
文章目录
第4章 控制流
4.1 条件表达式if/else
4.1.1 基础条件表达式
在Rust中，条件表达式是程序决策的基础。与其他语言不同，Rust的if表达式总是返回一个值，这使得它们更加灵活和强大。
fnbasic_conditionals(){println!("=== 基础条件表达式 ===");// 1. 基本的if表达式let number =7;if number <5{println!("条件为真");}else{println!("条件为假");}// 2. 多条件判断let score =85;if score >=90{println!("优秀");}elseif score >=80{println!("良好");}elseif score >=70{println!("中等");}elseif score >=60{println!("及格");}else{println!("不及格");}// 3. if作为表达式（返回值的if）let condition =true;let result =if condition {"真分支的值"}else{"假分支的值"};println!("if表达式结果: {}", result);// 4. 在let语句中使用if表达式let number =6;let is_even =if number %2==0{"偶数"}else{"奇数"};println!("{} 是 {}", number, is_even);// 5. 嵌套if表达式let x =10;let y =20;let comparison =if x > y {"x 大于 y"}elseif x < y {"x 小于 y"}else{"x 等于 y"};println!("比较结果: {}", comparison);// 6. 布尔值的隐式转换let flag =true;if flag {// 不需要写 if flag == trueprintln!("标志为真");}if!flag {// 不需要写 if flag == falseprintln!("标志为假");}}fnconditional_operators(){println!("\n=== 条件运算符 ===");// 1. 比较运算符let a =10;let b =20;println!("比较运算:");println!(" {} == {}: {}", a, b, a == b);println!(" {} != {}: {}", a, b, a != b);println!(" {} < {}: {}", a, b, a < b);println!(" {} > {}: {}", a, b, a > b);println!(" {} <= {}: {}", a, b, a <= b);println!(" {} >= {}: {}", a, b, a >= b);// 2. 逻辑运算符let has_permission =true;let has_credits =false;println!("逻辑运算:");println!(" 与运算: {}", has_permission && has_credits);println!(" 或运算: {}", has_permission || has_credits);println!(" 非运算: {}",!has_permission);// 3. 组合条件let age =25;let has_license =true;if age >=18&& has_license {println!("可以驾驶");}else{println!("不能驾驶");}// 4. 短路求值演示println!("\n短路求值演示:");fnexpensive_check()->bool{println!("执行昂贵检查...");true}let condition1 =false;let condition2 =true;// 由于condition1为false，expensive_check不会被调用if condition1 &&expensive_check(){println!("条件1为真");}// 由于condition2为true，expensive_check会被调用if condition2 ||expensive_check(){println!("条件2为真");}// 5. 复杂条件表达式let temperature =25;let is_sunny =true;let is_weekend =false;let should_go_out =if temperature >20&& temperature <30&& is_sunny {if is_weekend {"绝对要出门！"}else{"天气很好，但得上班"}}else{"还是呆在家里吧"};println!("出门建议: {}", should_go_out);}fnconditional_with_blocks(){println!("\n=== 带代码块的条件表达式 ===");// 1. 代码块可以有返回值let value =42;let description =if value >50{let temp = value *2;format!("大的数: {}", temp)}else{let temp = value /2;format!("小的数: {}", temp)};println!("描述: {}", description);// 2. 复杂的条件逻辑let user_role ="admin";let is_authenticated =true;let access_level =if is_authenticated {match user_role {"admin"=>{println("记录管理员访问");"full_access"},"user"=>{println("记录用户访问");"limited_access"},"guest"=>{println("记录访客访问");"read_only"}, _ =>"no_access"}}else{"unauthorized"};println!("访问级别: {}", access_level);// 3. 条件表达式中的变量作用域let config_value =Some(100);let processed_value =ifletSome(value)= config_value {// value 在这个分支内可用let result = value *2;format!("处理后的值: {}", result)}else{// value 在这里不可用"没有配置值".to_string()};println!("处理结果: {}", processed_value);}4.1.2 高级条件表达式模式
让我们探索一些更高级的条件表达式用法和模式。
fnadvanced_conditional_patterns(){println!("=== 高级条件表达式模式 ===");// 1. 守卫条件 (guard clauses)fnprocess_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));// 2. 条件赋值模式letmut counter =0;let max_attempts =3;// 在条件中执行赋值whilelettrue={ counter +=1; counter <= max_attempts }{println!("尝试 {} of {}", counter, max_attempts);}// 3. 复杂布尔表达式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);// 4. 模式匹配风格的if letlet config =Some("production");ifletSome(env)= config {println!("运行在 {} 环境", env);}// 5. 多变量条件绑定let point =(5,10);iflet(x, y)= point {if x >0&& y >0{println!("点 ({}, {}) 在第一象限", x, y);}}// 6. 条件表达式与错误处理fnparse_number(s:&str)->Result<i32,String>{if s.is_empty(){returnErr("字符串为空".to_string());}if!s.chars().all(|c| c.is_ascii_digit()){returnErr("包含非数字字符".to_string());}Ok(s.parse().unwrap())}matchparse_number("123"){Ok(num)=>println!("解析成功: {}", num),Err(e)=>println!("解析失败: {}", e),}// 7. 条件编译#[cfg(debug_assertions)]{println!("这是调试构建");}#[cfg(not(debug_assertions))]{println!("这是发布构建");}// 8. 基于特性的条件编译#[cfg(feature = "logging")]{println!("日志特性已启用");}}fnconditional_performance(){println!("\n=== 条件表达式性能考虑 ===");usestd::time::Instant;// 1. 条件顺序优化fncheck_conditions_optimized(value:i32)->bool{// 把最可能为假的条件放在前面if value <0{// 快速失败returnfalse;}if value >1000{// 另一个快速失败条件returnfalse;}// 昂贵的检查放在最后is_prime(value)}fncheck_conditions_unoptimized(value:i32)->bool{// 昂贵的检查放在前面ifis_prime(value){if value <0{returnfalse;}if value >1000{returnfalse;}true}else{false}}fnis_prime(n:i32)->bool{if n <=1{returnfalse;}if n <=3{returntrue;}if n %2==0|| n %3==0{returnfalse;}letmut i =5;while i * i <= n {if n % i ==0|| n %(i +2)==0{returnfalse;} i +=6;}true}let test_value =97;// 质数let start =Instant::now();let result1 =check_conditions_optimized(test_value);let duration1 = start.elapsed();let start =Instant::now();let result2 =check_conditions_unoptimized(test_value);let duration2 = start.elapsed();println!("优化版本: {} (耗时: {:?})", result1, duration1);println!("未优化版本: {} (耗时: {:?})", result2, duration2);// 2. 使用布尔运算的短路特性fnvalidate_input(input:&str)->bool{// 利用短路求值：先检查简单的条件!input.is_empty()&& input.len()<=100&& input.chars().all(|c| c.is_ascii_alphanumeric())}println!("输入验证: 'hello' -> {}",validate_input("hello"));println!("输入验证: '' -> {}",validate_input(""));}4.2 循环：loop、while、for
4.2.1 loop循环深度解析
loop循环是Rust中最基本的循环结构，它会无限循环直到显式中断。
fnloop_deep_dive(){println!("=== loop循环深度解析 ===");// 1. 基本loop循环letmut counter =0;loop{ counter +=1;println!("循环次数: {}", counter);if counter >=5{break;}}// 2. loop返回值let result =loop{ counter +=1;if counter >=10{break counter *2;// loop可以返回值}};println!("loop返回值: {}", result);// 3. 嵌套loop和标签'outer:loop{println!("进入外部循环");letmut inner_counter =0;'inner:loop{ inner_counter +=1;println!(" 内部循环: {}", inner_counter);if inner_counter >=3{break'inner;// 跳出内部循环}} counter +=1;if counter >=2{break'outer;// 跳出外部循环}}// 4. loop与模式匹配letmut 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;}}}// 5. 条件循环模拟letmut number =0;loop{ number +=1;// 使用条件控制循环if number %2==0{continue;// 跳过偶数}println!("奇数: {}", number);if number >=9{break;}}// 6. 复杂循环控制complex_loop_control();}fncomplex_loop_control(){println!("\n=== 复杂循环控制 ===");// 1. 循环中的错误处理letmut attempts =0;constMAX_ATTEMPTS:u32=3;let result =loop{ attempts +=1;println!("尝试 {}...", attempts);// 模拟可能失败的操作let success = attempts >=2;// 第二次尝试成功if success {breakOk("操作成功");}elseif attempts >=MAX_ATTEMPTS{breakErr("达到最大尝试次数");}// 模拟重试延迟std::thread::sleep(std::time::Duration::from_millis(100));};match result {Ok(msg)=>println!("结果: {}", msg),Err(err)=>println!("错误: {}", err),}// 2. 循环中的状态管理letmut state =LoopState::new();loop{ state.iteration +=1;match state.process(){ProcessResult::Continue=>{println!("继续迭代 {}", state.iteration);},ProcessResult::Break(reason)=>{println!("循环结束: {}", reason);break;},ProcessResult::Restart=>{println!("重启循环"); state =LoopState::new();continue;}}if state.iteration >=5{break;}}// 3. 基于事件的循环event_based_loop();}// 循环状态管理示例#[derive(Debug)]structLoopState{ iteration:u32, data:Vec<i32>,}implLoopState{fnnew()->Self{Self{ iteration:0, data:vec![1,2,3],}}fnprocess(&mutself)->ProcessResult{println!("处理状态: {:?}",self);// 模拟处理逻辑ifself.iteration ==2{ProcessResult::Restart}elseifself.iteration >=4{ProcessResult::Break("完成处理".to_string())}else{ProcessResult::Continue}}}#[derive(Debug)]enumProcessResult{Continue,Break(String),Restart,}fnevent_based_loop(){println!("\n=== 基于事件的循环 ===");usestd::collections::VecDeque;letmut event_queue =VecDeque::from([Event::Message("事件1".to_string()),Event::Message("事件2".to_string()),Event::Error("错误事件".to_string()),Event::Message("事件3".to_string()),Event::Shutdown,]);letmut running =true;while running &&!event_queue.is_empty(){ifletSome(event)= event_queue.pop_front(){match event {Event::Message(msg)=>{println!("处理消息: {}", msg);},Event::Error(err)=>{println!("处理错误: {}", err);},Event::Shutdown=>{println!("收到关机信号"); running =false;},}}// 模拟处理时间std::thread::sleep(std::time::Duration::from_millis(50));}println!("事件循环结束");}#[derive(Debug)]enumEvent{Message(String),Error(String),Shutdown,}4.2.2 while循环深度解析
while循环在满足条件时重复执行代码块。
fnwhile_loop_deep_dive(){println!("=== while循环深度解析 ===");// 1. 基本while循环letmut counter =0;while counter <5{println!("计数器: {}", counter); counter +=1;}// 2. while let 模式letmut stack =Vec::new(); stack.push(1); stack.push(2); stack.push(3);println!("栈内容:");whileletSome(top)= stack.pop(){println!("弹出: {}", top);}// 3. 复杂的while条件letmut x =100;while x >0{ x /=2;if x ==0{break;}println!("x = {}", x);}// 4. 使用while进行输入处理process_user_input_simulation();// 5. while循环与迭代器let numbers =[1,2,3,4,5];letmut iter = numbers.iter();whileletSome(&number)= iter.next(){if number ==3{println!("找到3，跳过剩余");break;}println!("处理数字: {}", number);}// 6. 条件递减循环letmut remaining_time =10;while remaining_time >0{println!("倒计时: {}秒", remaining_time); remaining_time -=1;std::thread::sleep(std::time::Duration::from_millis(100));}println!("时间到！");}fnprocess_user_input_simulation(){println!("\n=== 用户输入处理模拟 ===");usestd::collections::VecDeque;// 模拟用户输入队列letmut input_queue =VecDeque::from(["help".to_string(),"exit".to_string(),"invalid".to_string(),"status".to_string(),]);letmut running =true;while running &&!input_queue.is_empty(){let input = input_queue.pop_front().unwrap();match input.as_str(){"help"=>{println!("显示帮助信息");},"exit"=>{println!("退出程序"); running =false;},"status"=>{println!("显示状态信息");}, _ =>{println!("未知命令: {}", input);}}}println!("输入处理结束");}fnwhile_with_complex_conditions(){println!("\n=== 复杂条件的while循环 ===");// 1. 多条件while循环letmut temperature =20;letmut pressure =100;letmut iterations =0;while temperature <100&& pressure <200&& iterations <50{ temperature +=5; pressure +=10; iterations +=1;println!("迭代 {}: 温度={}, 压力={}", iterations, temperature, pressure);}// 2. 基于状态的while循环letmut state =ProcessingState::Initializing;letmut data =0;while!state.is_terminal(){ state = state.next(data); data +=10;println!("状态: {:?}, 数据: {}", state, data);// 防止无限循环if data >100{break;}}// 3. while循环中的continue和breakletmut number =0;while number <20{ number +=1;if number %3==0{continue;// 跳过3的倍数}if number ==16{println!("在16时提前退出");break;}println!("处理数字: {}", number);}}#[derive(Debug, PartialEq)]enumProcessingState{Initializing,Processing,Finalizing,Completed,Error,}implProcessingState{fnnext(self, data:i32)->Self{matchself{ProcessingState::Initializing=>{if data >=10{ProcessingState::Processing}else{ProcessingState::Initializing}},ProcessingState::Processing=>{if data >=50{ProcessingState::Finalizing}elseif data <0{ProcessingState::Error}else{ProcessingState::Processing}},ProcessingState::Finalizing=>{if data >=80{ProcessingState::Completed}else{ProcessingState::Finalizing}},ProcessingState::Completed=>ProcessingState::Completed,ProcessingState::Error=>ProcessingState::Error,}}fnis_terminal(&self)->bool{matches!(self,ProcessingState::Completed|ProcessingState::Error)}}4.2.3 for循环深度解析
for循环是Rust中最常用的循环结构，主要用于迭代集合。
fnfor_loop_deep_dive(){println!("=== for循环深度解析 ===");// 1. 基本for循环 - 范围迭代println!("范围迭代:");for i in0..5{// 0到4（不包含5）println!("i = {}", i);}println!("包含范围:");for i in0..=5{// 0到5（包含5）println!("i = {}", i);}// 2. 数组迭代let numbers =[10,20,30,40,50];println!("数组迭代:");for number in numbers {println!("数字: {}", number);}// 3. 向量迭代let names =vec!["Alice","Bob","Charlie"];println!("向量迭代:");for name in&names {// 使用引用避免所有权转移println!("名字: {}", name);}// 4. 带索引的迭代println!("带索引迭代:");for(index, name)in names.iter().enumerate(){println!("索引 {}: {}", index, name);}// 5. 字符串字符迭代let text ="Hello, 世界!";println!("字符迭代:");for(i, ch)in text.chars().enumerate(){println!("位置 {}: '{}' (U+{:04X})", i, ch, ch asu32);}// 6. 字节迭代println!("字节迭代:");for byte in text.bytes(){println!("字节: 0x{:02X}", byte);}// 7. 哈希映射迭代usestd::collections::HashMap;letmut scores =HashMap::new(); scores.insert("Alice",100); scores.insert("Bob",85); scores.insert("Charlie",92);println!("哈希映射迭代:");for(name, score)in&scores {println!("{}: {}", name, score);}// 8. 反向迭代println!("反向迭代:");for i in(0..5).rev(){println!("i = {}", i);}// 9. 步长迭代println!("步长迭代:");for i in(0..20).step_by(3){println!("i = {}", i);}// 10. 嵌套for循环println!("嵌套循环:");for i in0..3{for j in0..3{println!("({}, {})", i, j);}}// 11. 复杂的for循环模式advanced_for_patterns();}fnadvanced_for_patterns(){println!("\n=== 高级for循环模式 ===");// 1. 过滤迭代let numbers =1..=10;println!("过滤偶数:");for even in numbers.filter(|&x| x %2==0){println!("偶数: {}", even);}// 2. 映射迭代let numbers =1..=5;println!("数字平方:");for square in numbers.map(|x| x * x){println!("平方: {}", square);}// 3. 链式迭代器操作let result:Vec<i32>=(1..=10).filter(|&x| x %2==0)// 取偶数.map(|x| x *2)// 乘以2.collect();println!("链式操作结果: {:?}", result);// 4. for循环中的模式匹配let pairs =vec![(1,"one"),(2,"two"),(3,"three")];println!("元组解构:");for(number, word)in pairs {println!("{}: {}", number, word);}// 5. 结构体迭代#[derive(Debug)]structPoint{ x:i32, y:i32,}let points =vec![Point{ x:0, y:0},Point{ x:1, y:2},Point{ x:3, y:4},];println!("结构体迭代:");for point in points {println!("点: ({}, {})", point.x, point.y);}// 6. 跳过元素let numbers =1..=10;println!("跳过前3个:");for num in numbers.skip(3){println!("数字: {}", num);}// 7. 取前n个元素let numbers =1..=100;println!("前5个元素:");for num in numbers.take(5){println!("数字: {}", num);}// 8. 循环控制：break和continueprintln!("循环控制:");for i in1..=10{if i ==3{continue;// 跳过3}if i ==8{break;// 在8时退出}println!("i = {}", i);}// 9. 带标签的for循环'outer:for i in1..=3{'inner:for j in1..=3{if i * j >4{println!("跳过外部循环的剩余部分");continue'outer;}println!("({}, {})", i, j);}}// 10. 性能优化：使用迭代器代替索引let large_vec:Vec<i32>=(0..1000).collect();// 好：直接迭代letmut sum1 =0;for&num in&large_vec { sum1 += num;}// 不好：使用索引（可能有边界检查开销）letmut sum2 =0;for i in0..large_vec.len(){ sum2 += large_vec[i];}println!("求和结果: {} = {}", sum1, sum2);}fnfor_loop_with_custom_iterators(){println!("\n=== 自定义迭代器的for循环 ===");// 1. 自定义范围迭代器structStepRange{ start:i32, end:i32, step:i32,}implIteratorforStepRange{typeItem=i32;fnnext(&mutself)->Option<Self::Item>{ifself.start <self.end {let current =self.start;self.start +=self.step;Some(current)}else{None}}}println!("自定义步长迭代器:");for i inStepRange{ start:0, end:10, step:2}{println!("i = {}", i);}// 2. 斐波那契数列迭代器structFibonacci{ current:u64, next:u64,}implFibonacci{fnnew()->Self{Fibonacci{ current:0, next:1,}}}implIteratorforFibonacci{typeItem=u64;fnnext(&mutself)->Option<Self::Item>{let new_next =self.current.checked_add(self.next)?;let result =self.current;self.current =self.next;self.next = new_next;Some(result)}}println!("斐波那契数列:");for(i, fib)inFibonacci::new().enumerate().take(10){println!("F({}) = {}", i, fib);}// 3. 文件行迭代file_line_iteration_simulation();}fnfile_line_iteration_simulation(){println!("\n=== 文件行迭代模拟 ===");// 模拟文件内容let file_content ="第一行\n第二行\n第三行\n第四行";let lines = file_content.lines();println!("文件内容:");for(line_num, line)in lines.enumerate(){println!("行 {}: {}", line_num +1, line);}// 带过滤的文件行处理let log_content ="INFO: 系统启动\nERROR: 磁盘空间不足\nINFO: 用户登录\nWARN: 内存使用率高";println!("错误日志:");for line in log_content.lines().filter(|l| l.contains("ERROR")){println!("错误: {}", line);}}4.3 模式匹配与match表达式
4.3.1 match表达式基础
match是Rust中最强大的控制流工具之一，提供全面的模式匹配能力。
fnmatch_expression_basics(){println!("=== match表达式基础 ===");// 1. 基本match表达式let number =13;match number {1=>println!("一"),2|3|5|7|11=>println!("质数"),13..=19=>println!("青少年数字"), _ =>println!("其他数字"),}// 2. match返回值的用法let number =5;let description =match number {1=>"一",2=>"二",3=>"三", _ =>"很多",};println!("数字 {} 是 {}", number, description);// 3. 匹配布尔值let flag =true;match flag {true=>println!("真"),false=>println!("假"),}// 4. 匹配字符let grade ='A';match grade {'A'|'B'|'C'=>println!("及格"),'D'=>println!("勉强及格"),'F'=>println!("不及格"), _ =>println!("无效成绩"),}// 5. 匹配字符串切片let language ="Rust";match language {"Rust"=>println!("系统编程语言"),"Python"=>println!("脚本语言"),"Java"=>println!("企业级语言"), _ =>println!("其他语言"),}// 6. 穷尽性检查let boolean =true;// 必须处理所有可能的情况match boolean {true=>println!("真"),false=>println!("假"),}// 7. 使用 _ 通配符let value =42;match value {1=>println!("一"),2=>println!("二"), _ =>(),// 忽略其他所有情况}// 8. 匹配范围let age =25;match age {0..=12=>println!("儿童"),13..=19=>println!("青少年"),20..=64=>println!("成人"), _ =>println!("长者"),}}fnmatch_with_patterns(){println!("\n=== 模式匹配 ===");// 1. 解构元组let point =(0,5);match point {(0,0)=>println!("在原点"),(0, y)=>println!("在Y轴上，y = {}", y),(x,0)=>println!("在X轴上，x = {}", x),(x, y)=>println!("在点 ({}, {})", x, y),}// 2. 解构结构体structPoint{ x:i32, y:i32,}let point =Point{ x:10, y:20};match point {Point{ x:0, y:0}=>println!("在原点"),Point{ x, y:0}=>println!("在X轴上，x = {}", x),Point{ x:0, y }=>println!("在Y轴上，y = {}", y),Point{ x, y }=>println!("在点 ({}, {})", x, y),}// 3. 解构枚举enumMessage{Quit,Move{ x:i32, y:i32},Write(String),ChangeColor(i32,i32,i32),}let msg =Message::Move{ x:10, y:20};match msg {Message::Quit=>println!("退出"),Message::Move{ x, y }=>println!("移动到 ({}, {})", x, y),Message::Write(text)=>println!("文本消息: {}", text),Message::ChangeColor(r, g, b)=>println!("颜色改变为 ({}, {}, {})", r, g, b),}// 4. 匹配引用let reference =&4;match reference {&val =>println!("解引用得到: {}", val),}// 更简洁的写法：match*reference { val =>println!("直接得到: {}", val),}// 5. 匹配切片let arr =[1,2,3];match arr {[1, _, _]=>println!("以1开头"),[a, b, c]=>println!("数组: {}, {}, {}", a, b, c),}// 6. 守卫条件let pair =(2,-2);match pair {(x, y)if x == y =>println!("相等"),(x, y)if x + y ==0=>println!("相加为零"),(x, _)if x %2==0=>println("第一个是偶数"), _ =>println!("不匹配"),}// 7. @ 绑定let number =5;match number { n @1..=10=>println!("数字 {} 在1-10之间", n), n @11..=20=>println!("数字 {} 在11-20之间", n), n =>println!("数字 {} 不在范围内", n),}}fnadvanced_match_patterns(){println!("\n=== 高级模式匹配 ===");// 1. 嵌套模式匹配enumColor{Rgb(u8,u8,u8),Hsv(u8,u8,u8),}enumMessage{ChangeColor(Color),}let msg =Message::ChangeColor(Color::Rgb(255,0,0));match msg {Message::ChangeColor(Color::Rgb(r, g, b))=>{println!("改变RGB颜色为 ({}, {}, {})", r, g, b);},Message::ChangeColor(Color::Hsv(h, s, v))=>{println!("改变HSV颜色为 ({}, {}, {})", h, s, v);},}// 2. 匹配Option和Resultlet some_value =Some(5);let none_value:Option<i32>=None;match some_value {Some(x)=>println!("有值: {}", x),None=>println!("无值"),}match none_value {Some(x)=>println!("有值: {}", x),None=>println!("无值"),}// 3. 复杂的结果处理fndivide(a:f64, b:f64)->Result<f64,String>{if b ==0.0{Err("除数不能为零".to_string())}else{Ok(a / b)}}matchdivide(10.0,2.0){Ok(result)=>println!("结果: {}", result),Err(error)=>println!("错误: {}", error),}// 4. 匹配多种错误类型fncomplex_operation()->Result<i32,Box<dynstd::error::Error>>{// 模拟可能失败的操作Ok(42)}matchcomplex_operation(){Ok(value)=>println!("操作成功: {}", value),Err(e)=>{ifletSome(io_error)= e.downcast_ref::<std::io::Error>(){println!("IO错误: {}", io_error);}elseifletSome(parse_error)= e.downcast_ref::<std::num::ParseIntError>(){println!("解析错误: {}", parse_error);}else{println!("未知错误: {}", e);}}}// 5. 模式匹配与所有权let name =String::from("Alice");match name {// ref_name 是引用，不会取得所有权ref ref_name =>println!("名字是: {}", ref_name),}// name 仍然可用println!("名字仍然可用: {}", name);// 6. 匹配时移动值let person =Person{ name:String::from("Bob"), age:30,};match person {// 这里会移动person的所有权Person{ name, age }=>{println!("{} 今年 {} 岁", name, age);}}// person 不再可用// 7. 使用 _ 忽略值let triple =(1,2,3);match triple {(1, _, third)=>println!("第一个是1，第三个是 {}", third), _ =>println!("其他情况"),}}#[derive(Debug)]structPerson{ name:String, age:u32,}4.3.2 if let 和 while let
if let和while let提供了模式匹配的简洁语法。
fnif_let_while_let_patterns(){println!("=== if let 和 while let 模式 ===");// 1. 基本if let用法let some_value =Some(5);// 使用matchmatch some_value {Some(x)=>println!("值为: {}", x),None=>(),}// 使用if let（更简洁）ifletSome(x)= some_value {println!("值为: {}", x);}// 2. if let与elselet none_value:Option<i32>=None;ifletSome(x)= none_value {println!("有值: {}", x);}else{println!("没有值");}// 3. if let与守卫条件let some_number =Some(10);ifletSome(x)= some_number {if x >5{println!("值 {} 大于5", x);}}// 使用守卫的更简洁写法ifletSome(x)= some_number && x >5{println!("值 {} 大于5", x);}// 4. 解构复杂类型enumEvent{Click{ x:i32, y:i32},KeyPress(char),}let event =Event::Click{ x:100, y:200};ifletEvent::Click{ x, y }= event {println!("点击位置: ({}, {})", x, y);}// 5. while let循环letmut stack =Vec::new(); stack.push(1); stack.push(2); stack.push(3);println!("使用while let弹出栈:");whileletSome(top)= stack.pop(){println!("弹出: {}", top);}// 6. while let与迭代器let numbers =vec![1,2,3,4,5];letmut iter = numbers.iter();println!("使用while let迭代:");whileletSome(&number)= iter.next(){println!("数字: {}", number);}// 7. 复杂条件的while letletmut optional =Some(0);whileletSome(i)= optional {if i >9{println!("大于9，退出"); optional =None;}else{println!("`i` 是 `{:?}`，继续", i); optional =Some(i +1);}}// 8. if let在赋值中let config_max =Some(3u8);// 使用if let进行条件赋值let max_value =ifletSome(max)= config_max { max }else{0u8};println!("最大值: {}", max_value);// 9. 模式匹配与错误处理let result:Result<i32,&str>=Ok(42);ifletOk(value)= result {println!("成功: {}", value);}ifletErr(error)= result {println!("错误: {}", error);}// 10. 实际应用示例practical_if_let_examples();}fnpractical_if_let_examples(){println!("\n=== if let 实际应用示例 ===");// 1. 配置文件解析structConfig{ timeout:Option<u32>, retries:Option<u32>,}let config =Config{ timeout:Some(30), retries:None,};ifletSome(timeout)= config.timeout {println!("超时设置: {}秒", timeout);}else{println!("使用默认超时");}// 2. 用户输入处理let user_input ="42";ifletOk(number)= user_input.parse::<i32>(){println!("解析的数字: {}", number);}else{println!("无效的数字");}// 3. 可选的操作链letmut values =vec![Some(1),None,Some(3)];whileletSome(Some(value))= values.pop(){println!("处理值: {}", value);}// 4. 嵌套的可选值let nested_option =Some(Some(42));ifletSome(Some(value))= nested_option {println!("嵌套值: {}", value);}// 5. 带条件的if letlet numbers =vec![1,3,5,8,10];for number in numbers {iflet n @1..=5= number && n %2==1{println!("{} 是1-5之间的奇数", n);}}}fnmatch_vs_if_let(){println!("\n=== match 与 if let 的比较 ===");// 场景1：处理Optionlet option_value =Some(42);println!("使用match:");match option_value {Some(x)=>println!("值为: {}", x),None=>println!("没有值"),}println!("使用if let:");ifletSome(x)= option_value {println!("值为: {}", x);}else{println!("没有值");}// 场景2：只需要处理一种情况let result:Result<i32,&str>=Ok(100);// 如果我们只关心成功的情况ifletOk(value)= result {println!("成功: {}", value);}// 使用match会显得冗长match result {Ok(value)=>println!("成功: {}", value),Err(_)=>{},// 必须处理所有情况}// 场景3：复杂模式匹配enumComplexEnum{A(i32),B(String),C{ x:i32, y:i32},}let value =ComplexEnum::C{ x:10, y:20};// 使用match处理所有情况match value {ComplexEnum::A(n)=>println!("A: {}", n),ComplexEnum::B(s)=>println!("B: {}", s),ComplexEnum::C{ x, y }=>println!("C: ({}, {})", x, y),}// 如果只关心一种情况，使用if letifletComplexEnum::C{ x, y }= value {println!("只关心C: ({}, {})", x, y);}// 性能考虑performance_considerations();}fnperformance_considerations(){println!("\n=== 性能考虑 ===");// 1. match的穷尽性检查在编译时完成，没有运行时开销let value =Some(42);// 编译时确保所有情况都被处理match value {Some(x)=>println!("有值: {}", x),None=>println!("无值"),}// 2. if let编译为高效的代码ifletSome(x)= value {println!("有值: {}", x);}// 3. 复杂模式的优化let complex_value =(Some(1),Some("hello"));// match会检查所有分支match complex_value {(Some(a),Some(b))=>println!("都有值: {}, {}", a, b), _ =>println!("其他情况"),}// if let只检查特定模式iflet(Some(a),Some(b))= complex_value {println!("都有值: {}, {}", a, b);}// 4. 在实际代码中的选择建议println!("选择建议:");println!(" - 需要处理所有情况: 使用 match");println!(" - 只关心一种情况: 使用 if let");println!(" - 循环中的模式匹配: 使用 while let");println!(" - 需要守卫条件: match 更灵活");}4.4 控制流最佳实践
4.4.1 代码可读性与维护性
编写清晰、易于理解的控制流代码。
fnreadability_best_practices(){println!("=== 代码可读性最佳实践 ===");// 1. 使用有意义的变量名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!("可以驾驶");}// 2. 避免过深的嵌套complex_nested_logic();refactored_complex_logic();// 3. 使用守卫子句提前返回fnprocess_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(){returnErr("姓名为空".to_string());}if age <18{returnErr("用户未成年".to_string());}Ok(format!("用户 {} 年龄 {}", name, age))}// 4. 使用布尔变量简化复杂条件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!("好天气，没安排，出门吧！");}// 5. 匹配枚举时使用穷尽模式enumTrafficLight{Red,Yellow,Green,}let light =TrafficLight::Red;// 好：处理所有情况match light {TrafficLight::Red=>println!("停止"),TrafficLight::Yellow=>println!("准备"),TrafficLight::Green=>println!("通行"),}// 6. 使用注释解释复杂逻辑let score =85;// 成绩等级划分逻辑let grade =match score {// 90分以上为优秀90..=100=>"优秀",// 80-89分为良好80..=89=>"良好",// 70-79分为中等70..=79=>"中等",// 60-69分为及格60..=69=>"及格",// 其他为不及格 _ =>"不及格",};println!("成绩等级: {}", grade);}fncomplex_nested_logic(){println!("\n=== 复杂嵌套逻辑（反面教材） ===");let user_role ="admin";let is_authenticated =true;let has_permission =true;let resource_available =true;// 过深的嵌套 - 难以阅读和维护if is_authenticated {if user_role =="admin"{if has_permission {if resource_available {println!("操作成功");}else{println!("资源不可用");}}else{println!("权限不足");}}else{println!("角色不符");}}else{println!("未认证");}}fnrefactored_complex_logic(){println!("\n=== 重构后的逻辑 ===");let user_role ="admin";let is_authenticated =true;let has_permission =true;let resource_available =true;// 使用守卫子句和布尔变量扁平化逻辑if!is_authenticated {println!("未认证");return;}if user_role !="admin"{println!("角色不符");return;}if!has_permission {println!("权限不足");return;}if!resource_available {println!("资源不可用");return;}println!("操作成功");}4.4.2 错误处理模式
在控制流中优雅地处理错误。
fnerror_handling_patterns(){println!("=== 错误处理模式 ===");// 1. 使用Result和matchfnparse_number(s:&str)->Result<i32,String>{ s.parse().map_err(|_|"解析失败".to_string())}let input ="42";matchparse_number(input){Ok(number)=>println!("解析成功: {}", number),Err(error)=>println!("解析失败: {}", error),}// 2. 使用?操作符简化错误传播fnprocess_data(data:&str)->Result<i32,String>{let num1 =parse_number(data)?;let num2 =parse_number("100")?;Ok(num1 + num2)}// 3. 组合错误处理fncomprehensive_data_processing(input:&str)->Result<String,String>{// 多个可能失败的操作let number = input.parse::<i32>().map_err(|_|"数字解析失败".to_string())?;if number <0{returnErr("数字不能为负".to_string());}if number >1000{returnErr("数字太大".to_string());}Ok(format!("处理后的数字: {}", number *2))}// 4. 使用if let处理特定错误let result =comprehensive_data_processing("5000");ifletErr(error)=&result {if error =="数字太大"{println!("数字超出范围，但可以继续处理");}}// 5. 错误转换fnconvert_errors()->Result<(),String>{let input ="not_a_number";// 将不同的错误类型转换为统一的错误类型let _number:i32= input.parse().map_err(|e|format!("解析错误: {}", e))?;Ok(())}// 6. 可选值处理模式fnfind_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!("用户不存在"),}// 7. 使用unwrap_or提供默认值let user =find_user("guest").unwrap_or("默认用户");println!("用户: {}", user);// 8. 链式错误处理fncomplex_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),}}fnperformance_optimization(){println!("\n=== 性能优化 ===");// 1. 循环性能优化let large_vector:Vec<i32>=(0..1_000_000).collect();// 好：使用迭代器let sum:i32= large_vector.iter().sum();println!("迭代器求和: {}", sum);// 更好：使用foldlet sum = large_vector.iter().fold(0,|acc,&x| acc + x);println!("fold求和: {}", sum);// 2. 避免在循环中分配内存letmut results =Vec::with_capacity(1000);// 预分配容量for i in0..1000{ results.push(i *2);// 不会重新分配}// 3. 使用数组代替向量当大小固定时let fixed_data =[1,2,3,4,5];// 栈上分配，更快// 4. 匹配性能考虑let value =Some(42);// match在编译时优化，没有运行时开销match value {Some(x)=>println!("有值: {}", x),None=>println!("无值"),}// 5. 使用switch风格的匹配let number =5;// 编译器可以优化为跳转表match number {1=>println!("一"),2=>println!("二"),3=>println!("三"),4=>println!("四"),5=>println!("五"), _ =>println!("其他"),}// 6. 避免不必要的克隆let name =String::from("Alice");// 好：使用引用process_name(&name);// 不好：不必要的克隆process_name(name.clone());println!("名字仍然可用: {}", name);}fnprocess_name(name:&str){println!("处理名字: {}", name);}fnidiomatic_rust_patterns(){println!("\n=== Rust惯用模式 ===");// 1. 使用迭代器代替手动循环let numbers =vec![1,2,3,4,5];// 惯用写法let doubled:Vec<i32>= numbers.iter().map(|&x| x *2).collect();println!("加倍后: {:?}", doubled);// 2. 使用模式匹配处理Optionlet maybe_value =Some(42);// 惯用写法ifletSome(value)= maybe_value {println!("有值: {}", value);}// 3. 使用Result进行错误处理fnread_file()->Result<String,std::io::Error>{// 模拟文件读取Ok("文件内容".to_string())}// 惯用写法：使用?操作符fnprocess_file()->Result<(),Box<dynstd::error::Error>>{let content =read_file()?;println!("文件内容: {}", content);Ok(())}// 4. 使用枚举进行状态管理enumConnectionState{Disconnected,Connecting,Connected,Error(String),}let state =ConnectionState::Connected;// 惯用写法：模式匹配match state {ConnectionState::Disconnected=>println("断开连接"),ConnectionState::Connecting=>println("连接中"),ConnectionState::Connected=>println("已连接"),ConnectionState::Error(msg)=>println!("连接错误: {}", msg),}// 5. 使用结构体更新语法structConfig{ host:String, port:u16, timeout:u32,}let base_config =Config{ host:"localhost".to_string(), port:8080, timeout:30,};// 惯用写法let new_config =Config{ host:"127.0.0.1".to_string(),..base_config };// 6. 使用trait对象进行多态traitDrawable{fndraw(&self);}structCircle;structSquare;implDrawableforCircle{fndraw(&self){println!("绘制圆形");}}implDrawableforSquare{fndraw(&self){println!("绘制方形");}}let shapes:Vec<Box<dynDrawable>>=vec![Box::new(Circle),Box::new(Square),];// 惯用写法：使用trait对象for shape in shapes { shape.draw();}}fncontrol_flow_in_real_world(){println!("\n=== 实际项目中的控制流 ===");// 1. Web请求处理web_request_handling_simulation();// 2. 数据处理管道data_processing_pipeline();// 3. 状态机实现state_machine_implementation();}fnweb_request_handling_simulation(){println!("\n=== Web请求处理模拟 ===");enumHttpMethod{GET,POST,PUT,DELETE,}structHttpRequest{ method:HttpMethod, path:String, headers:Vec<(String,String)>, body:Option<String>,}fnhandle_request(request:HttpRequest)->Result<String,String>{// 验证请求if request.path.is_empty(){returnErr("路径不能为空".to_string());}// 路由处理match(request.method, request.path.as_str()){(HttpMethod::GET,"/api/users")=>{Ok("用户列表".to_string())},(HttpMethod::POST,"/api/users")=>{ifletSome(body)= request.body {Ok(format!("创建用户: {}", body))}else{Err("请求体为空".to_string())}},(HttpMethod::GET, path)if path.starts_with("/api/users/")=>{let user_id =&path["/api/users/".len()..];Ok(format!("用户详情: {}", user_id))}, _ =>{Err("未找到路由".to_string())}}}let request =HttpRequest{ method:HttpMethod::GET, path:"/api/users".to_string(), headers:vec![], body:None,};matchhandle_request(request){Ok(response)=>println!("响应: {}", response),Err(error)=>println!("错误: {}", error),}}fndata_processing_pipeline(){println!("\n=== 数据处理管道 ===");#[derive(Debug)]structDataPoint{ value:f64, timestamp:u64, quality:Quality,}#[derive(Debug)]enumQuality{Good,Bad,Unknown,}fnprocess_data_stream(data:Vec<DataPoint>)->Vec<DataPoint>{ data.into_iter().filter(|point|matches!(point.quality,Quality::Good)).filter(|point| point.value >=0.0&& point.value <=100.0).map(|mut point|{ point.value =(point.value *100.0).round()/100.0;// 保留两位小数 point }).collect()}let raw_data =vec![DataPoint{ value:23.456, timestamp:1000, quality:Quality::Good},DataPoint{ value:-5.0, timestamp:1001, quality:Quality::Good},DataPoint{ value:150.0, timestamp:1002, quality:Quality::Good},DataPoint{ value:45.678, timestamp:1003, quality:Quality::Bad},];let processed_data =process_data_stream(raw_data);println!("处理后的数据: {:?}", processed_data);}fnstate_machine_implementation(){println!("\n=== 状态机实现 ===");#[derive(Debug, Clone, Copy)]enumVendingMachineState{WaitingForPayment,SelectingProduct,DispensingProduct,OutOfOrder,}structVendingMachine{ state:VendingMachineState, balance:u32, selected_product:Option<u32>,}implVendingMachine{fnnew()->Self{Self{ state:VendingMachineState::WaitingForPayment, balance:0, selected_product:None,}}fninsert_coin(&mutself, amount:u32)->Result<(),String>{matchself.state {VendingMachineState::WaitingForPayment=>{self.balance += amount;ifself.balance >=100{self.state =VendingMachineState::SelectingProduct;}Ok(())}, _ =>Err("无法投币，机器状态不正确".to_string()),}}fnselect_product(&mutself, product_id:u32)->Result<(),String>{matchself.state {VendingMachineState::SelectingProduct=>{self.selected_product =Some(product_id);self.state =VendingMachineState::DispensingProduct;Ok(())}, _ =>Err("无法选择商品，机器状态不正确".to_string()),}}fndispense(&mutself)->Result<String,String>{matchself.state {VendingMachineState::DispensingProduct=>{ifletSome(product_id)=self.selected_product {self.balance =0;self.selected_product =None;self.state =VendingMachineState::WaitingForPayment;Ok(format!("分发商品 {}", product_id))}else{Err("没有选中的商品".to_string())}}, _ =>Err("无法分发商品，机器状态不正确".to_string()),}}}letmut machine =VendingMachine::new();// 正常流程println!("正常购买流程:");ifletErr(e)= machine.insert_coin(50){println!("错误: {}", e);}ifletErr(e)= machine.insert_coin(50){println!("错误: {}", e);}ifletErr(e)= machine.select_product(1){println!("错误: {}", e);}match machine.dispense(){Ok(msg)=>println!("成功: {}", msg),Err(e)=>println!("错误: {}", e),}// 错误流程println!("\n错误流程:");match machine.select_product(2){Ok(_)=>println!("选择成功"),Err(e)=>println!("错误: {}", e),}}通过本章的全面学习，你已经深入掌握了Rust的控制流系统。从基础的条件表达式到复杂的模式匹配，从简单的循环到高级的迭代器模式，你现在应该能够编写出既安全又高效的Rust控制流代码。在下一章中，我们将深入探讨Rust最独特的特性：所有权系统。
