filter 适配器 ​

核心概念 ​

filter() 是迭代器的过滤适配器,接受一个返回 bool 的闭包作为谓词(predicate),只保留让谓词返回 true 的元素,丢弃返回 false 的元素。filter() 是惰性的,不会改变元素的值或类型,只减少数量。闭包接收的是元素的引用(&&T 或 &T),因为 filter 只需要查看元素来做判断,不需要拥有它。

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

    // 过滤出偶数
    let evens: Vec<&i32> = numbers.iter()
        .filter(|&&x| x % 2 == 0)
        .collect();
    println!("偶数: {:?}", evens);

    // 过滤出大于 5 的数
    let big: Vec<&i32> = numbers.iter()
        .filter(|&&x| x > 5)
        .collect();
    println!("大于5: {:?}", big);

    // into_iter + filter:产出值而非引用
    let evens_owned: Vec<i32> = numbers.into_iter()
        .filter(|&x| x % 2 == 0)
        .collect();
    println!("偶数(owned): {:?}", evens_owned);
}

filter 闭包中的双重引用 ​

rust
fn main() {
    let data = vec![10, 20, 30, 40, 50];

    // iter() 产出 &i32
    // filter 接收 &&i32(对 &i32 的引用)
    let result: Vec<&i32> = data.iter()
        .filter(|x| **x > 25)  // x 是 &&i32,**x 得到 i32
        .collect();
    println!("方式1: {:?}", result);

    // 用模式匹配解构
    let result: Vec<&i32> = data.iter()
        .filter(|&&x| x > 25)  // 解构得到 i32
        .collect();
    println!("方式2: {:?}", result);

    // into_iter() 产出 i32
    // filter 接收 &i32
    let result: Vec<i32> = vec![10, 20, 30, 40, 50].into_iter()
        .filter(|&x| x > 25)  // x 是 &i32
        .collect();
    println!("方式3: {:?}", result);
}

filter 与 map 的配合 ​

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

    // 先过滤再转换
    let long_upper: Vec<String> = words.iter()
        .filter(|&&w| w.len() > 3)
        .map(|&w| w.to_uppercase())
        .collect();
    println!("长词大写: {:?}", long_upper);

    // 先转换再过滤
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let big_squares: Vec<i32> = numbers.iter()
        .map(|&x| x * x)
        .filter(|&x| x > 30)
        .collect();
    println!("平方>30: {:?}", big_squares);

    // 多重过滤
    let result: Vec<&i32> = numbers.iter()
        .filter(|&&x| x > 2)
        .filter(|&&x| x < 8)
        .filter(|&&x| x % 2 == 1)
        .collect();
    println!("2<x<8且奇数: {:?}", result);
}

filter 捕获环境变量 ​

rust
fn main() {
    let data = vec![15, 25, 35, 45, 55, 65, 75, 85, 95];

    // 闭包捕获外部变量作为过滤条件
    let min = 30;
    let max = 80;
    let in_range: Vec<&i32> = data.iter()
        .filter(|&&x| x >= min && x <= max)
        .collect();
    println!("{}~{}: {:?}", min, max, in_range);

    // 动态过滤条件
    let keywords = vec!["rust", "safe"];
    let texts = vec![
        "rust is a safe language",
        "python is easy",
        "rust compiler is strict",
        "java is verbose",
    ];

    let matches: Vec<&&str> = texts.iter()
        .filter(|&&text| {
            keywords.iter().any(|&kw| text.contains(kw))
        })
        .collect();
    println!("匹配结果: {:?}", matches);

    // 黑名单过滤
    let blacklist = vec![3, 7, 11];
    let nums = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
    let allowed: Vec<&i32> = nums.iter()
        .filter(|&&x| !blacklist.contains(&x))
        .collect();
    println!("排除黑名单: {:?}", allowed);
}

基本示例 ​

用 filter 构建一个日志查询系统:

rust
#[derive(Debug)]
struct LogEntry {
    timestamp: String,
    level: String,
    module: String,
    message: String,
}

impl LogEntry {
    fn new(ts: &str, level: &str, module: &str, msg: &str) -> Self {
        LogEntry {
            timestamp: ts.to_string(),
            level: level.to_string(),
            module: module.to_string(),
            message: msg.to_string(),
        }
    }
}

fn main() {
    let logs = vec![
        LogEntry::new("10:01", "INFO", "auth", "用户登录成功"),
        LogEntry::new("10:02", "DEBUG", "db", "查询用户表"),
        LogEntry::new("10:03", "ERROR", "api", "请求超时"),
        LogEntry::new("10:04", "INFO", "auth", "用户登出"),
        LogEntry::new("10:05", "WARN", "db", "连接池接近上限"),
        LogEntry::new("10:06", "ERROR", "db", "数据库连接失败"),
        LogEntry::new("10:07", "INFO", "api", "健康检查通过"),
        LogEntry::new("10:08", "DEBUG", "auth", "刷新 token"),
        LogEntry::new("10:09", "ERROR", "api", "空指针异常"),
        LogEntry::new("10:10", "INFO", "db", "重连成功"),
    ];

    // 查询所有错误日志
    println!("=== ERROR 日志 ===");
    let errors: Vec<&LogEntry> = logs.iter()
        .filter(|log| log.level == "ERROR")
        .collect();
    for log in &errors {
        println!("  [{}] [{}] {}", log.timestamp, log.module, log.message);
    }

    // 查询特定模块的日志
    let module = "db";
    println!("\n=== {} 模块日志 ===", module);
    let db_logs: Vec<&LogEntry> = logs.iter()
        .filter(|log| log.module == module)
        .collect();
    for log in &db_logs {
        println!("  [{}] [{}] {}", log.timestamp, log.level, log.message);
    }

    // 复合条件:非 DEBUG 的 api 模块日志
    println!("\n=== api 模块(非 DEBUG)===");
    logs.iter()
        .filter(|log| log.module == "api")
        .filter(|log| log.level != "DEBUG")
        .for_each(|log| {
            println!("  [{}] [{}] {}", log.timestamp, log.level, log.message);
        });

    // 统计各级别日志数量
    println!("\n=== 统计 ===");
    for level in &["INFO", "DEBUG", "WARN", "ERROR"] {
        let count = logs.iter()
            .filter(|log| log.level == *level)
            .count();
        println!("  {}: {}条", level, count);
    }

    // 关键词搜索
    let keyword = "连接";
    println!("\n=== 包含'{}' ===", keyword);
    logs.iter()
        .filter(|log| log.message.contains(keyword))
        .for_each(|log| {
            println!("  [{}] [{}] [{}] {}",
                log.timestamp, log.level, log.module, log.message);
        });
}

常见问题 ​

问题一:filter 和 filter_map 有什么区别?

filter 只做判断(返回 bool),不改变元素。filter_map 同时做判断和转换(返回 Option<T>),Some(值) 保留并转换,None 丢弃。filter_map 等价于 filter + map 的组合。

问题二:为什么 filter 闭包接收的是双重引用?

iter() 产出 &T,filter 对每个元素再取一次引用来判断(因为不需要拿走元素),所以闭包参数是 &&T。用 into_iter() 时,闭包参数是 &T。

问题三:多个 filter 链式调用和一个 filter 里写多个条件哪个好?

性能上几乎相同(编译器会优化)。多个 filter 更清晰可读,单个 filter 里用 && 更紧凑。看个人和团队偏好。

问题四:filter 后的元素顺序会改变吗?

不会。filter 保持原始顺序,只是移除不满足条件的元素。

适用场景 ​

  • 数据筛选:按条件过滤集合中的元素
  • 日志查询:按级别、模块、关键词过滤
  • 搜索功能:文本匹配、范围查询
  • 数据清洗:移除无效或不需要的数据

注意事项 ​

  • filter 是惰性的,需要消费器驱动
  • filter 不改变元素的值和类型,只减少数量
  • iter().filter() 的闭包参数是 &&T
  • into_iter().filter() 的闭包参数是 &T
  • filter 保持元素的原始顺序
  • 需要同时过滤和转换时用 filter_map

总结 ​

filter() 接受一个返回 bool 的谓词闭包,只保留返回 true 的元素。filter 是惰性的,不改变元素的值和类型,只减少数量,保持原始顺序。使用 iter() 时闭包参数是 &&T(双重引用),使用 into_iter() 时是 &T。filter 可以捕获外部变量作为过滤条件,多个 filter 可以链式调用。需要同时过滤和转换时用 filter_map。在实际项目中,filter 广泛用于数据筛选、日志查询、搜索功能等场景。