for 迭代器循环 ​

什么是 for 循环 ​

for 循环是 Rust 中遍历集合和范围最常用的方式。它自动调用迭代器的 next() 方法,每次取出一个元素执行循环体,直到迭代器耗尽。语法简洁,不需要手动管理索引,也不会有越界风险。

rust
fn main() {
    // 遍历数组
    let fruits = ["苹果", "香蕉", "橙子", "葡萄"];
    for fruit in &fruits {
        println!("{}", fruit);
    }

    // 遍历范围
    for i in 1..=5 {
        print!("{} ", i);  // 1 2 3 4 5
    }
    println!();
}

遍历集合的三种方式 ​

根据是否需要修改元素或消耗集合,for 循环有三种遍历方式。

rust
fn main() {
    let names = vec![
        String::from("张三"),
        String::from("李四"),
        String::from("王五"),
    ];

    // 方式一:不可变引用遍历(&T)
    // 不消耗集合,元素以引用形式访问
    for name in &names {
        println!("引用:{}", name);  // name 的类型是 &String
    }
    println!("集合仍可用,长度:{}", names.len());

    // 方式二:可变引用遍历(&mut T)
    let mut scores = vec![80, 90, 75, 85];
    for score in &mut scores {
        *score += 5;  // 修改每个元素
    }
    println!("加分后:{:?}", scores);

    // 方式三:消耗式遍历(T)
    // 集合的所有权被移入循环,循环后集合不可用
    let items = vec![String::from("A"), String::from("B"), String::from("C")];
    for item in items {
        println!("拥有:{}", item);  // item 的类型是 String(不是引用)
    }
    // println!("{:?}", items);  // 编译错误:items 已被消耗
}
写法迭代器方法元素类型集合是否可用
for x in &collection.iter()&T可用
for x in &mut collection.iter_mut()&mut T可用(已修改)
for x in collection.into_iter()T不可用(已消耗)

带索引遍历 ​

rust
fn main() {
    let colors = ["红", "橙", "黄", "绿", "蓝"];

    // enumerate() 返回 (索引, 元素) 元组
    for (i, color) in colors.iter().enumerate() {
        println!("第 {} 个颜色:{}", i + 1, color);
    }

    // 在 Vec 中查找元素的位置
    let data = vec![15, 42, 8, 23, 16];
    for (index, &value) in data.iter().enumerate() {
        if value > 20 {
            println!("索引 {} 的值 {} 大于 20", index, value);
        }
    }
}

遍历范围 ​

rust
fn main() {
    // 左闭右开范围
    print!("0..5: ");
    for i in 0..5 {
        print!("{} ", i);  // 0 1 2 3 4
    }
    println!();

    // 左闭右闭范围
    print!("1..=5: ");
    for i in 1..=5 {
        print!("{} ", i);  // 1 2 3 4 5
    }
    println!();

    // 反向遍历
    print!("反向: ");
    for i in (0..5).rev() {
        print!("{} ", i);  // 4 3 2 1 0
    }
    println!();

    // 步进遍历
    print!("步进: ");
    for i in (0..20).step_by(3) {
        print!("{} ", i);  // 0 3 6 9 12 15 18
    }
    println!();

    // 字符范围
    print!("字母: ");
    for ch in 'a'..='f' {
        print!("{} ", ch);  // a b c d e f
    }
    println!();
}

遍历迭代器链 ​

for 可以和迭代器适配器(map、filter 等)配合使用。

rust
fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // filter:只遍历偶数
    print!("偶数: ");
    for n in numbers.iter().filter(|&&x| x % 2 == 0) {
        print!("{} ", n);  // 2 4 6 8 10
    }
    println!();

    // map:遍历平方值
    print!("平方: ");
    for sq in numbers.iter().map(|&x| x * x) {
        print!("{} ", sq);  // 1 4 9 16 25 36 49 64 81 100
    }
    println!();

    // zip:同时遍历两个集合
    let names = vec!["张三", "李四", "王五"];
    let ages = vec![25, 30, 28];
    for (name, age) in names.iter().zip(ages.iter()) {
        println!("{} 今年 {} 岁", name, age);
    }

    // take:只取前 N 个
    print!("前三个: ");
    for n in numbers.iter().take(3) {
        print!("{} ", n);  // 1 2 3
    }
    println!();

    // skip:跳过前 N 个
    print!("跳过三个: ");
    for n in numbers.iter().skip(3) {
        print!("{} ", n);  // 4 5 6 7 8 9 10
    }
    println!();
}

遍历 HashMap ​

rust
use std::collections::HashMap;

fn main() {
    let mut scores: HashMap<&str, i32> = HashMap::new();
    scores.insert("数学", 95);
    scores.insert("语文", 88);
    scores.insert("英语", 92);

    // 遍历键值对
    for (subject, score) in &scores {
        println!("{}: {} 分", subject, score);
    }

    // 只遍历键
    print!("科目: ");
    for subject in scores.keys() {
        print!("{} ", subject);
    }
    println!();

    // 只遍历值
    let total: i32 = scores.values().sum();
    println!("总分: {}", total);

    // 可变遍历修改值
    for score in scores.values_mut() {
        *score += 5;  // 每科加 5 分
    }
    println!("加分后: {:?}", scores);
}

遍历字符串 ​

rust
fn main() {
    let text = "Hello你好";

    // 按字符遍历
    print!("字符: ");
    for ch in text.chars() {
        print!("'{}' ", ch);
    }
    println!();

    // 按字节遍历
    print!("字节: ");
    for byte in text.bytes() {
        print!("{:02x} ", byte);
    }
    println!();

    // 按单词遍历
    let sentence = "Rust is a systems programming language";
    for (i, word) in sentence.split_whitespace().enumerate() {
        println!("单词 {}: {}", i + 1, word);
    }

    // 按行遍历
    let multiline = "第一行\n第二行\n第三行";
    for line in multiline.lines() {
        println!("-> {}", line);
    }
}

基本示例 ​

用 for 循环实现一些常见操作:

rust
fn main() {
    // 矩阵转置
    let matrix = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
    ];

    // 计算转置后的行数和列数
    let rows = matrix.len();
    let cols = matrix[0].len();
    let mut transposed = vec![vec![0; rows]; cols];

    for i in 0..rows {
        for j in 0..cols {
            transposed[j][i] = matrix[i][j];
        }
    }

    println!("原矩阵:");
    for row in &matrix {
        println!("  {:?}", row);
    }
    println!("转置后:");
    for row in &transposed {
        println!("  {:?}", row);
    }

    // 统计文本中每个字符出现的次数
    let text = "hello world rust programming";
    let mut freq: std::collections::HashMap<char, u32> = std::collections::HashMap::new();

    for ch in text.chars() {
        if ch != ' ' {
            *freq.entry(ch).or_insert(0) += 1;
        }
    }

    // 按频率排序输出
    let mut freq_vec: Vec<(char, u32)> = freq.into_iter().collect();
    freq_vec.sort_by(|a, b| b.1.cmp(&a.1));

    println!("\n字符频率(前 10):");
    for (ch, count) in freq_vec.iter().take(10) {
        println!("  '{}' -> {} 次", ch, count);
    }
}

常见问题 ​

问题一:for 和 while 该选哪个?

场景推荐理由
遍历集合for自动处理迭代器,不会越界
遍历范围for语法简洁
条件不确定的循环while条件不是"遍历完就结束"
需要手动控制索引while 或 loopfor 不方便跳步、回退

问题二:for 循环中可以修改集合的长度吗?

不可以。for 循环持有集合的借用(或所有权),循环体内不能 push 或 remove。如果需要在遍历时增删元素,用 retain 方法(删除),或者先收集需要的数据再修改。

问题三:for 循环的性能和手动索引一样吗?

在大多数情况下一样。Rust 的迭代器是零成本抽象——编译器会把 for x in &arr 优化成和手动索引一样的机器码。而且 for 循环还避免了边界检查的开销(编译器知道不会越界)。

问题四:for 循环可以返回值吗?

for 循环总是返回 ()。如果需要从循环中产出结果,用 collect() 收集迭代器结果,或者在循环外定义变量累积结果。

适用场景 ​

  • 遍历集合:数组、Vec、HashMap、HashSet 等
  • 遍历范围:0..n、1..=100 等数字序列
  • 遍历字符串:按字符、按字节、按单词、按行
  • 迭代器链处理:配合 filter、map、zip 等进行数据转换
  • 嵌套遍历:矩阵操作、笛卡尔积等

注意事项 ​

  • for x in collection 会消耗集合的所有权,后续不能再用
  • 要保留集合就用 for x in &collection
  • 要修改元素就用 for x in &mut collection
  • for 循环中不能修改集合的长度(不能 push/remove)
  • 不需要手动管理索引,需要索引时用 .enumerate()
  • for 循环总是返回 ()
  • 空集合的 for 循环不会执行循环体

总结 ​

for 循环是 Rust 中遍历集合和范围的标准方式,语法是 for 变量 in 迭代器 { 循环体 }。三种遍历方式——&collection(不可变引用)、&mut collection(可变引用)、collection(消耗所有权)——覆盖了所有常见场景。配合 enumerate() 可以获取索引,配合 filter()、map()、zip() 等迭代器适配器可以实现复杂的数据处理。for 循环是零成本抽象,性能和手动索引一样,而且更安全、更简洁。