flat_map 扁平映射 ​

核心概念 ​

flat_map() 是迭代器适配器,它对每个元素应用闭包产生一个迭代器,然后将所有产生的迭代器展平成一个连续的迭代器。可以理解为"先 map 再 flatten"的组合。flat_map 既可以改变元素数量(一个元素展开为多个,或者产出空迭代器来跳过),也可以改变元素类型。它在处理嵌套结构、文本分词、一对多映射等场景中非常有用。

rust
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 的关系 ​

rust
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 改变元素数量 ​

rust
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 处理嵌套结构 ​

rust
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 与文本处理 ​

rust
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 构建一个权限展开系统:

rust
#[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 返回迭代器(任意数量)。