filter_map 过滤映射
核心概念
filter_map() 是迭代器适配器,它同时完成过滤和转换两个操作。闭包返回 Option<U>:返回 Some(值) 时保留并转换元素,返回 None 时丢弃元素。filter_map 等价于 map 加 filter 再 unwrap 的组合,但更简洁高效。它在处理可能失败的转换(如字符串解析)时特别有用——成功就保留结果,失败就跳过。
fn main() {
let strings = vec!["1", "hello", "3", "world", "5"];
// filter_map:解析成功保留,失败跳过
let numbers: Vec<i32> = strings.iter()
.filter_map(|s| s.parse::<i32>().ok()) // ok() 把 Result 转为 Option
.collect();
println!("解析成功的数字: {:?}", numbers); // [1, 3, 5]
// 等价的 filter + map 写法(更冗长)
let numbers2: Vec<i32> = strings.iter()
.map(|s| s.parse::<i32>())
.filter(|r| r.is_ok())
.map(|r| r.unwrap())
.collect();
println!("等价写法: {:?}", numbers2);
}filter_map 的工作原理
fn main() {
let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// 闭包返回 Some 时保留,None 时丢弃
let result: Vec<String> = data.iter()
.filter_map(|&x| {
if x % 3 == 0 {
Some(format!("{}是3的倍数", x)) // 保留并转换
} else {
None // 丢弃
}
})
.collect();
println!("{:?}", result);
// 对比 filter + map
let result2: Vec<String> = data.iter()
.filter(|&&x| x % 3 == 0)
.map(|&x| format!("{}是3的倍数", x))
.collect();
println!("{:?}", result2); // 结果相同
}| 方法 | 闭包返回值 | 作用 |
|---|---|---|
filter | bool | 只过滤,不转换 |
map | U | 只转换,不过滤 |
filter_map | Option<U> | 同时过滤和转换 |
常见的 filter_map 模式
fn main() {
// 模式1:parse + ok()
let inputs = vec!["42", "abc", "100", "", "7"];
let nums: Vec<i32> = inputs.iter()
.filter_map(|s| s.parse().ok())
.collect();
println!("解析: {:?}", nums);
// 模式2:Option 值提取
let options = vec![Some(1), None, Some(3), None, Some(5)];
let values: Vec<i32> = options.into_iter()
.filter_map(|x| x) // 等价于 .flatten()
.collect();
println!("Option提取: {:?}", values);
// 模式3:HashMap 查找
use std::collections::HashMap;
let scores: HashMap<&str, i32> = [("张三", 92), ("李四", 78), ("王五", 85)]
.into_iter().collect();
let names = vec!["张三", "赵六", "王五", "钱七"];
let found_scores: Vec<(&str, i32)> = names.iter()
.filter_map(|&name| {
scores.get(name).map(|&score| (name, score))
})
.collect();
println!("查找到: {:?}", found_scores);
// 模式4:条件性转换
let words = vec!["hello", "hi", "hey", "world", "rust", "programming"];
let long_upper: Vec<String> = words.iter()
.filter_map(|&w| {
if w.len() > 3 {
Some(w.to_uppercase())
} else {
None
}
})
.collect();
println!("长词大写: {:?}", long_upper);
}filter_map 与错误处理
fn main() {
// 忽略错误,只保留成功结果
let raw_data = vec!["100", "abc", "200.5", "300", "xyz", "400"];
let integers: Vec<i32> = raw_data.iter()
.filter_map(|s| s.parse::<i32>().ok())
.collect();
println!("整数: {:?}", integers);
// 收集错误信息
let (successes, failures): (Vec<_>, Vec<_>) = raw_data.iter()
.map(|s| s.parse::<i32>())
.enumerate()
.partition(|(_, result)| result.is_ok());
let values: Vec<i32> = successes.into_iter()
.filter_map(|(_, r)| r.ok())
.collect();
let error_indices: Vec<usize> = failures.into_iter()
.map(|(i, _)| i)
.collect();
println!("成功值: {:?}", values);
println!("失败索引: {:?}", error_indices);
// 实际场景:解析配置行
let config_lines = vec![
"timeout = 30",
"# 这是注释",
"retries = 3",
"",
"port = 8080",
"无效行",
];
let config: Vec<(String, String)> = config_lines.iter()
.filter_map(|line| {
let line = line.trim();
// 跳过空行和注释
if line.is_empty() || line.starts_with('#') {
return None;
}
// 尝试按 = 分割
let parts: Vec<&str> = line.splitn(2, '=').collect();
if parts.len() == 2 {
Some((parts[0].trim().to_string(), parts[1].trim().to_string()))
} else {
None // 无效格式,跳过
}
})
.collect();
println!("\n配置:");
for (key, value) in &config {
println!(" {} = {}", key, value);
}
}基本示例
用 filter_map 构建一个数据清洗管道:
#[derive(Debug)]
struct CleanRecord {
name: String,
age: u32,
email: String,
}
fn clean_and_parse(raw_lines: &[&str]) -> Vec<CleanRecord> {
raw_lines.iter()
.filter_map(|line| {
let fields: Vec<&str> = line.split(',').map(|f| f.trim()).collect();
// 必须有 3 个字段
if fields.len() != 3 {
return None;
}
let name = fields[0].to_string();
let age_str = fields[1];
let email = fields[2].to_string();
// 名字不能为空
if name.is_empty() {
return None;
}
// 年龄必须是有效数字且在合理范围
let age = match age_str.parse::<u32>() {
Ok(a) if a > 0 && a < 150 => a,
_ => return None,
};
// 邮箱必须包含 @
if !email.contains('@') {
return None;
}
Some(CleanRecord { name, age, email })
})
.collect()
}
fn main() {
let raw_data = vec![
"张三, 25, zhangsan@example.com",
"李四, abc, lisi@example.com", // 年龄无效
", 30, anonymous@example.com", // 名字为空
"王五, 28, wangwu_at_example.com", // 邮箱无效
"赵六, 35, zhaoliu@example.com",
"钱七, 200, qianqi@example.com", // 年龄不合理
"孙八, 22, sunba@example.com",
"多余字段, 30, email@test.com, 额外", // 字段数量不对
"周九, 40, zhoujiu@example.com",
];
let clean = clean_and_parse(&raw_data);
println!("=== 原始数据: {} 条 ===", raw_data.len());
println!("=== 清洗后: {} 条 ===\n", clean.len());
for (i, record) in clean.iter().enumerate() {
println!(" {}. {} | {}岁 | {}", i + 1, record.name, record.age, record.email);
}
// 统计
let avg_age: f64 = clean.iter()
.map(|r| r.age as f64)
.sum::<f64>() / clean.len() as f64;
println!("\n平均年龄: {:.1}", avg_age);
let rejection_rate = (raw_data.len() - clean.len()) as f64 / raw_data.len() as f64 * 100.0;
println!("拒绝率: {:.1}%", rejection_rate);
// 链式 filter_map:多步转换
let emails: Vec<String> = raw_data.iter()
.filter_map(|line| {
let fields: Vec<&str> = line.split(',').collect();
fields.get(2).map(|e| e.trim().to_string())
})
.filter_map(|email| {
if email.contains('@') {
let domain = email.split('@').nth(1)?;
Some(format!("{} (域名: {})", email, domain))
} else {
None
}
})
.collect();
println!("\n有效邮箱:");
for email in &emails {
println!(" {}", email);
}
}常见问题
问题一:filter_map 和 filter + map 哪个好?
如果过滤和转换逻辑紧密关联(如解析成功就保留,失败就丢弃),filter_map 更简洁。如果过滤条件和转换逻辑独立,分开写更清晰。
问题二:filter_map 和 flat_map 有什么区别?
filter_map 闭包返回 Option<U>,Some 保留 None 丢弃。flat_map 闭包返回一个迭代器,将所有迭代器的元素展平。filter_map(f) 等价于 flat_map(|x| f(x).into_iter())。
问题三:filter_map 中怎么同时记录被跳过的元素?
标准 filter_map 不支持。可以用 partition 或在闭包中捕获外部 Vec 来记录失败项,但更清晰的做法是用 map + partition。
问题四:.ok() 和 .err() 在 filter_map 中的含义?
Result::ok() 将 Ok(v) 转为 Some(v),Err 转为 None。Result::err() 相反。在 filter_map 中 .ok() 用于"成功就保留,失败就跳过"。
适用场景
- 字符串解析:
parse().ok()跳过无效数据 - 数据清洗:一步完成验证和转换
- Option 提取:从
Vec<Option<T>>提取Vec<T> - 查找映射:在 HashMap/集合中查找并转换
注意事项
filter_map是惰性的,需要消费器驱动- 闭包返回
Option<U>,Some保留None丢弃 - 比
filter+map更简洁但可读性取决于场景 filter_map(|x| x)可以从Option迭代器提取值(等价于flatten).ok()是filter_map中处理Result的常用模式filter_map同时改变元素类型和数量
总结
filter_map() 同时完成过滤和转换:闭包返回 Some(值) 保留并转换元素,返回 None 丢弃元素。最常见的用法是 .filter_map(|s| s.parse().ok())——解析成功就保留,失败就跳过。filter_map 等价于 filter + map 的组合但更简洁。它在数据清洗、字符串解析、Option 提取、HashMap 查找等场景中广泛使用。当过滤条件和转换逻辑紧密关联时优先使用 filter_map;如果两者独立,分开用 filter 和 map 更清晰。