filter 适配器
核心概念
filter() 是迭代器的过滤适配器,接受一个返回 bool 的闭包作为谓词(predicate),只保留让谓词返回 true 的元素,丢弃返回 false 的元素。filter() 是惰性的,不会改变元素的值或类型,只减少数量。闭包接收的是元素的引用(&&T 或 &T),因为 filter 只需要查看元素来做判断,不需要拥有它。
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 闭包中的双重引用
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 的配合
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 捕获环境变量
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 构建一个日志查询系统:
#[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()的闭包参数是&&Tinto_iter().filter()的闭包参数是&Tfilter保持元素的原始顺序- 需要同时过滤和转换时用
filter_map
总结
filter() 接受一个返回 bool 的谓词闭包,只保留返回 true 的元素。filter 是惰性的,不改变元素的值和类型,只减少数量,保持原始顺序。使用 iter() 时闭包参数是 &&T(双重引用),使用 into_iter() 时是 &T。filter 可以捕获外部变量作为过滤条件,多个 filter 可以链式调用。需要同时过滤和转换时用 filter_map。在实际项目中,filter 广泛用于数据筛选、日志查询、搜索功能等场景。