enumerate 枚举 ​

核心概念 ​

enumerate() 是迭代器适配器,为每个元素附加一个从 0 开始的索引,将原来的元素 T 转换为 (usize, T) 元组。它是遍历集合时同时获取索引和值的标准方式,比手动维护索引变量更安全、更简洁。enumerate() 是惰性的,不会立即执行,本质上等价于 (0..).zip(iter)。

rust
fn main() {
    let fruits = vec!["苹果", "香蕉", "橘子", "葡萄", "西瓜"];

    // enumerate 为每个元素附加索引
    for (index, fruit) in fruits.iter().enumerate() {
        println!("  [{}] {}", index, fruit);
    }

    // 收集为 Vec
    let indexed: Vec<(usize, &&str)> = fruits.iter().enumerate().collect();
    println!("\n收集: {:?}", indexed);

    // 索引从 0 开始
    let mut iter = fruits.iter().enumerate();
    println!("\n手动 next:");
    println!("  {:?}", iter.next());  // Some((0, &"苹果"))
    println!("  {:?}", iter.next());  // Some((1, &"香蕉"))
}

enumerate 在实际场景中的用法 ​

rust
fn main() {
    let scores = vec![85, 92, 78, 95, 88, 72, 91];

    // 查找最高分的位置
    let (max_idx, max_val) = scores.iter()
        .enumerate()
        .max_by_key(|&(_, &score)| score)
        .unwrap();
    println!("最高分: 第{}个, {}分", max_idx + 1, max_val);

    // 查找所有大于 90 的位置
    let high_indices: Vec<usize> = scores.iter()
        .enumerate()
        .filter(|&(_, &s)| s > 90)
        .map(|(i, _)| i)
        .collect();
    println!("高分位置: {:?}", high_indices);

    // 带编号的输出
    let names = vec!["张三", "李四", "王五", "赵六"];
    println!("\n花名册:");
    names.iter()
        .enumerate()
        .for_each(|(i, name)| {
            println!("  {}. {}", i + 1, name);
        });

    // 奇偶位置分组
    let data = vec![10, 20, 30, 40, 50, 60];
    let (evens, odds): (Vec<_>, Vec<_>) = data.iter()
        .enumerate()
        .partition(|(i, _)| i % 2 == 0);
    println!("\n偶数位: {:?}", evens);
    println!("奇数位: {:?}", odds);
}

enumerate 与其他适配器配合 ​

rust
fn main() {
    let words = vec!["hello", "world", "rust", "programming", "language"];

    // enumerate + filter:找到特定条件的索引
    let long_word_positions: Vec<usize> = words.iter()
        .enumerate()
        .filter(|(_, w)| w.len() > 4)
        .map(|(i, _)| i)
        .collect();
    println!("长单词位置: {:?}", long_word_positions);

    // enumerate + map:生成带编号的格式化输出
    let numbered: Vec<String> = words.iter()
        .enumerate()
        .map(|(i, w)| format!("{}. {}", i + 1, w))
        .collect();
    println!("编号: {:?}", numbered);

    // enumerate + take:只处理前 N 个
    let first_three: Vec<(usize, &&str)> = words.iter()
        .enumerate()
        .take(3)
        .collect();
    println!("前三: {:?}", first_three);

    // enumerate + skip + take:切片效果
    let middle: Vec<(usize, &&str)> = words.iter()
        .enumerate()
        .skip(1)
        .take(3)
        .collect();
    println!("中间: {:?}", middle);

    // filter 后再 enumerate:注意索引会重新从 0 开始
    let re_indexed: Vec<(usize, &&str)> = words.iter()
        .filter(|w| w.len() <= 5)
        .enumerate()  // 过滤后重新编号
        .collect();
    println!("过滤后重新编号: {:?}", re_indexed);

    // enumerate 后再 filter:保留原始索引
    let original_idx: Vec<(usize, &&str)> = words.iter()
        .enumerate()  // 先编号
        .filter(|(_, w)| w.len() <= 5)
        .collect();
    println!("保留原始索引: {:?}", original_idx);
}

enumerate 与手动索引的对比 ​

rust
fn main() {
    let items = vec!["A", "B", "C", "D"];

    // 手动维护索引(不推荐)
    let mut index = 0;
    for item in &items {
        println!("  [{}] {}", index, item);
        index += 1;
    }

    // enumerate(推荐)
    for (i, item) in items.iter().enumerate() {
        println!("  [{}] {}", i, item);
    }

    // 手动索引的风险:如果有 continue/break,索引可能不正确
    // enumerate 不会有这个问题
    let nums = vec![1, 2, 3, 4, 5, 6];
    println!("\n跳过偶数:");
    for (i, &n) in nums.iter().enumerate() {
        if n % 2 == 0 { continue; }
        // 即使跳过了一些元素,i 仍然是正确的原始索引
        println!("  原始位置 [{}] = {}", i, n);
    }
}

基本示例 ​

用 enumerate 构建一个文本搜索功能:

rust
fn search_lines<'a>(text: &'a str, keyword: &str) -> Vec<(usize, &'a str)> {
    text.lines()
        .enumerate()
        .filter(|(_, line)| line.contains(keyword))
        .map(|(i, line)| (i + 1, line))  // 行号从 1 开始
        .collect()
}

fn main() {
    let source_code = r#"fn main() {
    let x = 42;
    let y = x + 10;
    println!("x = {}", x);
    let z = x * y;
    println!("z = {}", z);
    if z > 100 {
        println!("大于100");
    }
}"#;

    // 搜索包含 "println" 的行
    println!("=== 搜索 'println' ===");
    let results = search_lines(source_code, "println");
    for (line_num, line) in &results {
        println!("  第{}行: {}", line_num, line.trim());
    }
    println!("  共 {} 处匹配", results.len());

    // 搜索包含 "let" 的行
    println!("\n=== 搜索 'let' ===");
    let results = search_lines(source_code, "let");
    for (line_num, line) in &results {
        println!("  第{}行: {}", line_num, line.trim());
    }

    // 显示所有行及行号
    println!("\n=== 完整代码 ===");
    for (i, line) in source_code.lines().enumerate() {
        println!("  {:>3} | {}", i + 1, line);
    }

    // 统计非空行
    let non_empty = source_code.lines()
        .enumerate()
        .filter(|(_, line)| !line.trim().is_empty())
        .count();
    println!("\n非空行数: {}", non_empty);

    // 最长的行
    if let Some((line_num, longest)) = source_code.lines()
        .enumerate()
        .max_by_key(|(_, line)| line.len())
    {
        println!("最长行: 第{}行 ({}字符)", line_num + 1, longest.len());
    }
}

常见问题 ​

问题一:enumerate 的索引从几开始?

从 0 开始。如果需要从 1 开始的编号,在使用时对索引加 1:(i + 1, item)。

问题二:filter 后再 enumerate 和 enumerate 后再 filter 有什么区别?

filter().enumerate() 会重新从 0 编号(只编号过滤后的元素)。enumerate().filter() 保留原始索引。根据需求选择顺序。

问题三:enumerate 可以用于 into_iter 吗?

可以。vec.into_iter().enumerate() 产出 (usize, T),元素带有所有权。

问题四:enumerate 和 position 有什么关系?

position() 是查找第一个满足条件的元素的索引,返回 Option<usize>。enumerate().filter() 可以找到所有满足条件的索引。position 适合找单个,enumerate 适合处理全部。

适用场景 ​

  • 带编号输出:列表编号、行号显示
  • 位置查找:查找元素在集合中的位置
  • 索引相关操作:奇偶位分组、按位置过滤
  • 代码/文本处理:行号标注、搜索定位

注意事项 ​

  • 索引从 0 开始,显示时可能需要加 1
  • enumerate 是惰性的,需要消费器驱动
  • 与 filter 的顺序影响索引是否为原始位置
  • 本质上等价于 (0..).zip(iter)
  • 索引类型是 usize
  • 手动维护索引变量容易出错,优先用 enumerate

总结 ​

enumerate() 为迭代器的每个元素附加从 0 开始的 usize 索引,产出 (usize, T) 元组。它是同时获取索引和元素值的标准方式,比手动维护索引变量更安全。注意 filter 和 enumerate 的顺序:先 enumerate 后 filter 保留原始索引,先 filter 后 enumerate 从 0 重新编号。enumerate 广泛用于带编号输出、位置查找、文本行号标注等场景。本质上等价于 (0..).zip(iter),但语义更清晰。