enumerate 枚举
核心概念
enumerate() 是迭代器适配器,为每个元素附加一个从 0 开始的索引,将原来的元素 T 转换为 (usize, T) 元组。它是遍历集合时同时获取索引和值的标准方式,比手动维护索引变量更安全、更简洁。enumerate() 是惰性的,不会立即执行,本质上等价于 (0..).zip(iter)。
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 在实际场景中的用法
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 与其他适配器配合
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 与手动索引的对比
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 构建一个文本搜索功能:
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),但语义更清晰。