flat_map 扁平映射
核心概念
flat_map() 是迭代器适配器,它对每个元素应用闭包产生一个迭代器,然后将所有产生的迭代器展平成一个连续的迭代器。可以理解为"先 map 再 flatten"的组合。flat_map 既可以改变元素数量(一个元素展开为多个,或者产出空迭代器来跳过),也可以改变元素类型。它在处理嵌套结构、文本分词、一对多映射等场景中非常有用。
fn main() {
let sentences = vec!["hello world", "foo bar baz", "rust lang"];
// flat_map:将每个句子拆分为单词
let words: Vec<&str> = sentences.iter()
.flat_map(|s| s.split_whitespace())
.collect();
println!("单词: {:?}", words);
// ["hello", "world", "foo", "bar", "baz", "rust", "lang"]
// 等价的 map + flatten 写法
let words2: Vec<&str> = sentences.iter()
.map(|s| s.split_whitespace())
.flatten()
.collect();
println!("等价: {:?}", words2);
}flat_map 与 map + flatten 的关系
fn main() {
let data = vec![1, 2, 3];
// map 产出迭代器的迭代器(嵌套)
let nested: Vec<Vec<i32>> = data.iter()
.map(|&x| vec![x, x * 10, x * 100])
.collect();
println!("嵌套: {:?}", nested);
// [[1, 10, 100], [2, 20, 200], [3, 30, 300]]
// flat_map 直接展平
let flat: Vec<i32> = data.iter()
.flat_map(|&x| vec![x, x * 10, x * 100])
.collect();
println!("展平: {:?}", flat);
// [1, 10, 100, 2, 20, 200, 3, 30, 300]
// map + flatten 等价于 flat_map
let flat2: Vec<i32> = data.iter()
.map(|&x| vec![x, x * 10, x * 100])
.flatten()
.collect();
println!("map+flatten: {:?}", flat2);
}flat_map 改变元素数量
fn main() {
let data = vec![1, 2, 3, 4, 5];
// 一对多:每个元素展开为多个
let expanded: Vec<i32> = data.iter()
.flat_map(|&x| vec![x, -x]) // 每个数产生正负两个
.collect();
println!("一对多: {:?}", expanded);
// 一对零或一:等价于 filter_map
let filtered: Vec<i32> = data.iter()
.flat_map(|&x| {
if x % 2 == 0 { Some(x * 10) } else { None }
})
.collect();
println!("过滤: {:?}", filtered);
// 动态数量:每个元素重复自身次数
let repeated: Vec<i32> = vec![1, 2, 3].iter()
.flat_map(|&x| std::iter::repeat(x).take(x as usize))
.collect();
println!("重复: {:?}", repeated); // [1, 2, 2, 3, 3, 3]
// 空迭代器跳过某些元素
let with_gaps: Vec<&str> = vec!["hello", "", "world", "", "rust"].iter()
.flat_map(|&s| {
if s.is_empty() {
Vec::new() // 空:跳过
} else {
vec![s] // 保留
}
})
.collect();
println!("去空: {:?}", with_gaps);
}flat_map 处理嵌套结构
fn main() {
// 展平嵌套 Vec
let nested = vec![vec![1, 2, 3], vec![4, 5], vec![6, 7, 8, 9]];
let flat: Vec<&i32> = nested.iter()
.flat_map(|inner| inner.iter())
.collect();
println!("展平嵌套Vec: {:?}", flat);
// 展平嵌套 Option
let options: Vec<Option<Vec<i32>>> = vec![
Some(vec![1, 2]),
None,
Some(vec![3, 4, 5]),
None,
Some(vec![6]),
];
let values: Vec<&i32> = options.iter()
.flat_map(|opt| opt.iter().flat_map(|v| v.iter()))
.collect();
println!("展平Option<Vec>: {:?}", values);
// 结构体中的集合字段
struct Department {
name: String,
members: Vec<String>,
}
let departments = vec![
Department {
name: "工程部".to_string(),
members: vec!["张三".to_string(), "李四".to_string()],
},
Department {
name: "设计部".to_string(),
members: vec!["王五".to_string()],
},
Department {
name: "市场部".to_string(),
members: vec!["赵六".to_string(), "钱七".to_string(), "孙八".to_string()],
},
];
// 展平所有部门的成员
let all_members: Vec<&String> = departments.iter()
.flat_map(|dept| dept.members.iter())
.collect();
println!("所有成员: {:?}", all_members);
// 带部门名的成员列表
let member_info: Vec<String> = departments.iter()
.flat_map(|dept| {
dept.members.iter()
.map(move |name| format!("{} - {}", dept.name, name))
})
.collect();
println!("\n成员详情:");
for info in &member_info {
println!(" {}", info);
}
}flat_map 与文本处理
fn main() {
let text = "Rust 是一门注重安全的语言。\n它的所有权系统很独特。\n编译器非常严格。";
// 按行分割后再按字分割
let chars: Vec<char> = text.lines()
.flat_map(|line| line.chars())
.filter(|c| !c.is_whitespace())
.collect();
println!("所有字符(去空格): {} 个", chars.len());
// 按句子分词
let words: Vec<&str> = text.lines()
.flat_map(|line| line.split(|c: char| !c.is_alphanumeric() && c != '_'))
.filter(|w| !w.is_empty())
.collect();
println!("所有词: {:?}", words);
// 生成 N-gram
let sentence = "hello world rust";
let bigrams: Vec<String> = sentence.split_whitespace()
.collect::<Vec<&str>>()
.windows(2)
.map(|pair| format!("{} {}", pair[0], pair[1]))
.collect();
println!("二元组: {:?}", bigrams);
}基本示例
用 flat_map 构建一个权限展开系统:
#[derive(Debug)]
struct Role {
name: String,
permissions: Vec<String>,
}
impl Role {
fn new(name: &str, permissions: Vec<&str>) -> Self {
Role {
name: name.to_string(),
permissions: permissions.iter().map(|s| s.to_string()).collect(),
}
}
}
#[derive(Debug)]
struct User {
name: String,
roles: Vec<Role>,
}
impl User {
fn new(name: &str, roles: Vec<Role>) -> Self {
User {
name: name.to_string(),
roles,
}
}
// 获取用户的所有权限(展平角色中的权限)
fn all_permissions(&self) -> Vec<&str> {
self.roles.iter()
.flat_map(|role| role.permissions.iter().map(|p| p.as_str()))
.collect()
}
// 去重后的权限
fn unique_permissions(&self) -> Vec<&str> {
let mut perms: Vec<&str> = self.all_permissions();
perms.sort();
perms.dedup();
perms
}
fn has_permission(&self, perm: &str) -> bool {
self.roles.iter()
.flat_map(|role| role.permissions.iter())
.any(|p| p == perm)
}
}
fn main() {
let users = vec![
User::new("张三", vec![
Role::new("管理员", vec!["读取", "写入", "删除", "管理用户"]),
Role::new("审计员", vec!["读取", "查看日志"]),
]),
User::new("李四", vec![
Role::new("编辑", vec!["读取", "写入"]),
]),
User::new("王五", vec![
Role::new("访客", vec!["读取"]),
]),
];
// 展示每个用户的权限
for user in &users {
println!("用户: {}", user.name);
println!(" 角色: {:?}", user.roles.iter().map(|r| &r.name).collect::<Vec<_>>());
println!(" 所有权限: {:?}", user.all_permissions());
println!(" 去重权限: {:?}", user.unique_permissions());
println!(" 有删除权限: {}", user.has_permission("删除"));
println!();
}
// 系统级:所有用户的所有角色
let all_roles: Vec<&str> = users.iter()
.flat_map(|u| u.roles.iter().map(|r| r.name.as_str()))
.collect();
println!("系统所有角色: {:?}", all_roles);
// 所有用户的所有权限(去重)
let mut all_perms: Vec<&str> = users.iter()
.flat_map(|u| u.all_permissions())
.collect();
all_perms.sort();
all_perms.dedup();
println!("系统所有权限: {:?}", all_perms);
// 查找拥有特定权限的用户
let perm = "删除";
let users_with_perm: Vec<&str> = users.iter()
.filter(|u| u.has_permission(perm))
.map(|u| u.name.as_str())
.collect();
println!("拥有'{}'权限的用户: {:?}", perm, users_with_perm);
}常见问题
问题一:flat_map 和 filter_map 有什么区别?
filter_map 闭包返回 Option<T>,一个元素最多产出一个结果(保留或丢弃)。flat_map 闭包返回一个迭代器,一个元素可以产出零个、一个或多个结果。filter_map(f) 可以用 flat_map(|x| f(x).into_iter()) 来表达。
问题二:flat_map 和 flatten 有什么关系?
flat_map(f) 等价于 map(f).flatten()。flatten() 只展平一层嵌套(Iterator<Item = Iterator> → Iterator),不做转换。
问题三:flat_map 可以展平多层嵌套吗?
一次 flat_map 只展平一层。多层嵌套需要多次调用,或者在闭包中手动展平。
问题四:flat_map 是惰性的吗?
是的。flat_map 本身不执行计算,需要消费器(collect、for_each 等)驱动。
适用场景
- 文本分词:将文本按行、按词展开
- 嵌套展平:
Vec<Vec<T>>→Vec<T> - 一对多映射:每个元素产出多个结果
- 权限展开:角色→权限、用户→角色→权限
注意事项
flat_map是惰性的,需要消费器驱动- 闭包必须返回实现了
IntoIterator的类型 flat_map只展平一层嵌套flat_map(f)等价于map(f).flatten()- 闭包返回空迭代器等效于跳过该元素
- 闭包中使用
move时注意所有权
总结
flat_map() 对每个元素应用闭包产生一个迭代器,然后将所有迭代器展平为一个连续序列。它等价于 map().flatten(),但更简洁。flat_map 既可以增加元素数量(一对多),也可以减少(返回空迭代器跳过)。典型应用包括文本分词(按行再按词展开)、嵌套集合展平(Vec<Vec<T>> → Vec<T>)、权限/角色的多级展开等。与 filter_map 的区别在于:filter_map 返回 Option(零或一个),flat_map 返回迭代器(任意数量)。