rust学习-循环
- [1. loop 循环](#1. loop 循环)
-
- [从 loop 返回值](#从 loop 返回值)
- [2. while 循环](#2. while 循环)
-
- [while let 模式](#while let 模式)
- [3. for 循环](#3. for 循环)
- [4. 循环控制语句](#4. 循环控制语句)
- [5. 循环标签](#5. 循环标签)
- [6. 迭代器与循环](#6. 迭代器与循环)
- [7. 性能考虑](#7. 性能考虑)
-
- [迭代器 vs 索引访问](#迭代器 vs 索引访问)
- 循环展开
- [8. 常见模式与最佳实践](#8. 常见模式与最佳实践)
-
- [模式1: 搜索模式](#模式1: 搜索模式)
- [模式2: 累积模式](#模式2: 累积模式)
- [模式3: 转换模式](#模式3: 转换模式)
- [模式4: 窗口迭代](#模式4: 窗口迭代)
1. loop 循环
loop 是 Rust 中最简单的循环，它会无限循环直到显式中断。
基本语法
rust
loop {
// 代码块
}示例
rust
fn main() {
let mut count = 0;
loop {
count += 1;
println!("计数: {}", count);
if count >= 5 {
break; // 退出循环
}
}
}从 loop 返回值
rust
fn main() {
let mut counter = 0;
let result = loop {
counter += 1;
if counter == 10 {
break counter * 2; // 从循环返回值
}
};
println!("结果为: {}", result); // 输出: 20
}2. while 循环
while 循环在条件为真时重复执行代码块。
基本语法
rust
while condition {
// 代码块
}示例
rust
fn main() {
let mut number = 3;
while number != 0 {
println!("{}!", number);
number -= 1;
}
println!("发射!");
}while let 模式
rust
fn main() {
let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);
// 当弹出操作返回 Some(value) 时继续循环
while let Some(top) = stack.pop() {
println!("{}", top);
}
}3. for 循环
for 循环主要用于遍历集合或范围。
基本语法
rust
for item in collection {
// 代码块
}遍历范围
rust
fn main() {
// 范围 1..5 包含 1, 2, 3, 4
for i in 1..5 {
println!("i = {}", i);
}
// 范围 1..=5 包含 1, 2, 3, 4, 5
for i in 1..=5 {
println!("i = {}", i);
}
// 递减范围
for i in (1..5).rev() {
println!("i = {}", i);
}
}遍历数组/向量
rust
fn main() {
let arr = [10, 20, 30, 40, 50];
// 直接遍历元素
for element in arr {
println!("值为: {}", element);
}
// 遍历索引和值
for (index, value) in arr.iter().enumerate() {
println!("索引 {} 的值为 {}", index, value);
}
// 遍历向量
let vec = vec!["Rust", "Python", "Lua", "Go"];
for language in vec {
println!("编程语言: {}", language);
}
}遍历字符串
rust
fn main() {
let s = "Hello, Rust!";
// 遍历字符
for c in s.chars() {
println!("字符: {}", c);
}
// 遍历字节
for b in s.bytes() {
println!("字节: {}", b);
}
}4. 循环控制语句
break
rust
fn main() {
for i in 0..10 {
if i == 5 {
break; // 当 i == 5 时退出循环
}
println!("i = {}", i);
}
}continue
rust
fn main() {
for i in 0..10 {
if i % 2 == 0 {
continue; // 跳过偶数
}
println!("奇数: {}", i);
}
}break 和 continue 在嵌套循环中
rust
fn main() {
let mut count = 0;
'outer: for x in 0..5 {
for y in 0..5 {
count += 1;
if y == 2 {
continue; // 跳过当前内层循环的剩余部分
}
if x == 3 && y == 3 {
break 'outer; // 跳出外层循环
}
println!("({}, {})", x, y);
}
}
println!("总循环次数: {}", count);
}5. 循环标签
Rust 可为循环添加标签，以便在嵌套循环中精确控制 break 和 continue。
示例
rust
fn main() {
let mut matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
let target = 5;
'outer: for (i, row) in matrix.iter().enumerate() {
'inner: for (j, &item) in row.iter().enumerate() {
if item == target {
println!("找到 {} 在位置 ({}, {})", target, i, j);
break 'outer; // 跳出外层循环
}
}
}
}6. 迭代器与循环
常用迭代器方法
rust
fn main() {
let numbers = vec![1, 2, 3, 4, 5];
// map: 转换每个元素
for n in numbers.iter().map(|x| x * 2) {
println!("加倍: {}", n);
}
// filter: 过滤元素
for n in numbers.iter().filter(|&&x| x % 2 == 0) {
println!("偶数: {}", n);
}
// zip: 合并两个迭代器
let names = vec!["aaa", "bbb", "ccc"];
for (name, &number) in names.iter().zip(numbers.iter()) {
println!("{}: {}", name, number);
}
// chain: 连接迭代器
let more_numbers = vec![6, 7, 8];
for n in numbers.iter().chain(more_numbers.iter()) {
println!("连接后: {}", n);
}
}迭代器适配器
rust
fn main() {
let numbers = 1..=10;
// 链式调用迭代器方法
let result: Vec<i32> = numbers
.filter(|&x| x % 2 == 0) // 保留偶数
.map(|x| x * x) // 平方
.take(3) // 取前3个
.collect(); // 收集到向量中
println!("结果: {:?}", result); // [4, 16, 36]
}7. 性能考虑
迭代器 vs 索引访问
rust
fn main() {
let vec = vec![1, 2, 3, 4, 5];
// 方式1: 使用索引 (可能越界)
for i in 0..vec.len() {
println!("元素[{}] = {}", i, vec[i]);
}
// 方式2: 使用迭代器 (更安全)
for (i, value) in vec.iter().enumerate() {
println!("元素[{}] = {}", i, value);
}
// 方式3: 使用 get 方法 (安全，需要处理 Option)
for i in 0..vec.len() {
if let Some(value) = vec.get(i) {
println!("元素[{}] = {}", i, value);
}
}
}循环展开
rust
fn sum_array(arr: &[i32]) -> i32 {
let mut sum = 0;
// 手动循环展开可以提高性能
let chunks = arr.chunks_exact(4);
let remainder = chunks.remainder();
for chunk in chunks {
// 每次处理4个元素
sum += chunk[0] + chunk[1] + chunk[2] + chunk[3];
}
// 处理剩余元素
for &value in remainder {
sum += value;
}
sum
}
fn main() {
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
println!("总和: {}", sum_array(&arr));
}8. 常见模式与最佳实践
模式1: 搜索模式
rust
fn find_first_even(numbers: &[i32]) -> Option<&i32> {
for number in numbers {
if number % 2 == 0 {
return Some(number);
}
}
None
}
fn main() {
let numbers = [1, 3, 5, 7, 8, 9];
if let Some(even) = find_first_even(&numbers) {
println!("找到第一个偶数: {}", even);
}
}模式2: 累积模式
rust
fn calculate_product(numbers: &[i32]) -> i32 {
let mut product = 1;
for &number in numbers {
product *= number;
}
product
}
fn main() {
let numbers = [1, 2, 3, 4, 5];
println!("乘积: {}", calculate_product(&numbers));
}模式3: 转换模式
rust
fn to_uppercase_strings(strings: &[&str]) -> Vec<String> {
let mut result = Vec::new();
for s in strings {
result.push(s.to_uppercase());
}
result
}
// 使用迭代器更简洁的写法
fn to_uppercase_strings_iter(strings: &[&str]) -> Vec<String> {
strings.iter().map(|s| s.to_uppercase()).collect()
}
fn main() {
let strings = ["hello", "world", "rust"];
println!("{:?}", to_uppercase_strings(&strings));
}模式4: 窗口迭代
rust
fn sliding_window_average(data: &[f64], window_size: usize) -> Vec<f64> {
let mut averages = Vec::new();
for window in data.windows(window_size) {
let sum: f64 = window.iter().sum();
averages.push(sum / window_size as f64);
}
averages
}
fn main() {
let data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
let averages = sliding_window_average(&data, 3);
println!("滑动窗口平均值: {:?}", averages);
}