filter_map 过滤映射 ​

核心概念 ​

filter_map() 是迭代器适配器,它同时完成过滤和转换两个操作。闭包返回 Option<U>:返回 Some(值) 时保留并转换元素,返回 None 时丢弃元素。filter_map 等价于 map 加 filter 再 unwrap 的组合,但更简洁高效。它在处理可能失败的转换(如字符串解析)时特别有用——成功就保留结果,失败就跳过。

rust
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 的工作原理 ​

rust
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);  // 结果相同
}
方法闭包返回值作用
filterbool只过滤,不转换
mapU只转换,不过滤
filter_mapOption<U>同时过滤和转换

常见的 filter_map 模式 ​

rust
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 与错误处理 ​

rust
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 构建一个数据清洗管道:

rust
#[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 更清晰。