zip 组合 ​

核心概念 ​

zip() 将两个迭代器"拉链式"组合在一起,每次从两个迭代器各取一个元素组成一个元组 (A, B)。当任意一个迭代器耗尽时,zip 就停止——以较短的那个为准。zip 是惰性适配器,不会立即执行,需要消费器驱动。它常用于并行遍历两个集合、给元素配对索引、以及合并多源数据。

rust
fn main() {
    let names = vec!["Alice", "Bob", "Charlie"];
    let scores = vec![92, 85, 78];

    // zip 将两个迭代器配对
    let paired: Vec<(&&str, &i32)> = names.iter().zip(scores.iter()).collect();
    println!("配对: {:?}", paired);

    // 常见用法:直接在 for 循环中解构
    for (name, score) in names.iter().zip(scores.iter()) {
        println!("  {} 得了 {} 分", name, score);
    }

    // 长度不同时以较短的为准
    let a = vec![1, 2, 3, 4, 5];
    let b = vec!["x", "y", "z"];
    let zipped: Vec<_> = a.iter().zip(b.iter()).collect();
    println!("长度不同: {:?}", zipped);  // 只有3对
}

zip 的截断行为 ​

rust
fn main() {
    let long = vec![1, 2, 3, 4, 5, 6, 7, 8];
    let short = vec!["a", "b", "c"];

    // 以短的为准,多余的元素被忽略
    let result: Vec<_> = long.iter().zip(short.iter()).collect();
    println!("截断: {:?}", result);  // [(1,"a"), (2,"b"), (3,"c")]

    // 两个都为空
    let empty1: Vec<i32> = vec![];
    let empty2: Vec<&str> = vec![];
    let result: Vec<_> = empty1.iter().zip(empty2.iter()).collect();
    println!("空zip: {:?}", result);  // []

    // 一个为空
    let result: Vec<_> = long.iter().zip(empty2.iter()).collect();
    println!("一空: {:?}", result);  // []

    // 与无穷迭代器配合
    let data = vec!["a", "b", "c", "d"];
    let indexed: Vec<_> = (0..).zip(data.iter()).collect();
    println!("无穷+有限: {:?}", indexed);  // [(0,"a"), (1,"b"), ...]
}

zip 与 enumerate 的关系 ​

rust
fn main() {
    let items = vec!["苹果", "香蕉", "橘子"];

    // enumerate 其实就是 zip 的特殊情况
    // enumerate() 等价于 (0..).zip(iter)
    let with_enum: Vec<_> = items.iter().enumerate().collect();
    let with_zip: Vec<_> = (0..).zip(items.iter()).collect();

    println!("enumerate: {:?}", with_enum);
    println!("zip(0..): {:?}", with_zip);

    // 但 zip 更灵活:可以从任意数字开始
    let from_100: Vec<_> = (100..).zip(items.iter()).collect();
    println!("从100开始: {:?}", from_100);

    // 或者用自定义序列
    let labels = vec!["A", "B", "C"];
    let labeled: Vec<_> = labels.iter().zip(items.iter()).collect();
    println!("自定义标签: {:?}", labeled);
}

多个迭代器的 zip ​

rust
fn main() {
    let names = vec!["张三", "李四", "王五"];
    let ages = vec![25, 30, 28];
    let cities = vec!["北京", "上海", "广州"];

    // 链式 zip:三个迭代器
    let combined: Vec<_> = names.iter()
        .zip(ages.iter())
        .zip(cities.iter())
        .map(|((name, age), city)| {
            format!("{}, {}岁, {}", name, age, city)
        })
        .collect();

    println!("三路zip:");
    for info in &combined {
        println!("  {}", info);
    }

    // 四个迭代器
    let scores = vec![92.0, 85.5, 78.0];
    let records: Vec<_> = names.iter()
        .zip(ages.iter())
        .zip(cities.iter())
        .zip(scores.iter())
        .map(|(((name, age), city), score)| {
            format!("{} | {} | {} | {:.1}分", name, age, city, score)
        })
        .collect();

    println!("\n四路zip:");
    for record in &records {
        println!("  {}", record);
    }
}

zip 与 unzip ​

rust
fn main() {
    let data = vec![(1, "a"), (2, "b"), (3, "c"), (4, "d")];

    // unzip:zip 的逆操作,将元组迭代器拆分为两个集合
    let (numbers, letters): (Vec<i32>, Vec<&str>) = data.into_iter().unzip();
    println!("numbers: {:?}", numbers);
    println!("letters: {:?}", letters);

    // 先 zip 再 unzip(round-trip)
    let keys = vec!["name", "age", "city"];
    let values = vec!["张三", "25", "北京"];

    let pairs: Vec<_> = keys.iter().zip(values.iter()).collect();
    println!("pairs: {:?}", pairs);

    let (k, v): (Vec<_>, Vec<_>) = keys.iter()
        .zip(values.iter())
        .unzip();
    println!("keys: {:?}", k);
    println!("values: {:?}", v);
}

基本示例 ​

用 zip 实现向量运算和数据合并:

rust
fn main() {
    // === 向量运算 ===
    let vec_a = vec![1.0, 2.0, 3.0, 4.0];
    let vec_b = vec![5.0, 6.0, 7.0, 8.0];

    // 向量加法
    let sum: Vec<f64> = vec_a.iter()
        .zip(vec_b.iter())
        .map(|(&a, &b)| a + b)
        .collect();
    println!("加法: {:?}", sum);

    // 点积
    let dot_product: f64 = vec_a.iter()
        .zip(vec_b.iter())
        .map(|(&a, &b)| a * b)
        .sum();
    println!("点积: {:.1}", dot_product);

    // 逐元素比较
    let comparison: Vec<&str> = vec_a.iter()
        .zip(vec_b.iter())
        .map(|(&a, &b)| {
            if a > b { ">" } else if a < b { "<" } else { "=" }
        })
        .collect();
    println!("比较: {:?}", comparison);

    // === 数据合并 ===
    let headers = vec!["姓名", "年龄", "城市", "职业"];
    let row1 = vec!["张三", "25", "北京", "工程师"];
    let row2 = vec!["李四", "30", "上海", "设计师"];

    // 将表头和数据行配对
    println!("\n=== 记录1 ===");
    for (header, value) in headers.iter().zip(row1.iter()) {
        println!("  {}: {}", header, value);
    }

    println!("\n=== 记录2 ===");
    for (header, value) in headers.iter().zip(row2.iter()) {
        println!("  {}: {}", header, value);
    }

    // 构建 HashMap
    use std::collections::HashMap;
    let record: HashMap<&str, &str> = headers.iter()
        .zip(row1.iter())
        .map(|(&h, &v)| (h, v))
        .collect();
    println!("\nHashMap: {:?}", record);

    // === 差异比较 ===
    let old_prices = vec![100, 200, 300, 400, 500];
    let new_prices = vec![110, 190, 320, 400, 480];
    let products = vec!["A", "B", "C", "D", "E"];

    println!("\n=== 价格变动 ===");
    products.iter()
        .zip(old_prices.iter().zip(new_prices.iter()))
        .for_each(|(name, (&old, &new))| {
            let diff = new - old;
            let symbol = if diff > 0 { "+" } else { "" };
            println!("  产品{}: {} → {} ({}{})", name, old, new, symbol, diff);
        });
}

常见问题 ​

问题一:zip 两个长度不同的迭代器会怎样?

以较短的为准。较长迭代器中多余的元素被忽略,不会报错。如果需要以较长的为准并补充默认值,标准库没有直接提供,但可以用 itertools crate 的 zip_longest。

问题二:zip 可以组合两个以上的迭代器吗?

标准库的 zip 一次只能组合两个。要组合三个以上,可以链式调用 .zip(iter1).zip(iter2),但需要嵌套解构 ((a, b), c)。itertools crate 提供了 izip! 宏支持多路 zip。

问题三:zip 和 enumerate 有什么关系?

enumerate() 等价于 (0..).zip(iter)。zip 更通用——可以用任意迭代器作为索引源。

问题四:zip 可以用于不同类型的迭代器吗?

可以。zip 的两个迭代器可以产出完全不同的类型,结果是 (A, B) 元组。

适用场景 ​

  • 并行遍历:同时遍历两个相关集合
  • 数据配对:表头与数据行、键与值
  • 向量运算:逐元素加减乘除、点积
  • 差异比较:比较两组数据的变化

注意事项 ​

  • zip 以较短迭代器的长度为准
  • zip 是惰性的,需要消费器驱动
  • 多路 zip 需要嵌套,解构时层次较深
  • unzip 是 zip 的逆操作
  • enumerate() 是 (0..).zip(iter) 的快捷方式
  • zip 不要求两个迭代器的元素类型相同

总结 ​

zip() 将两个迭代器拉链式组合,每次各取一个元素组成 (A, B) 元组。当任意一个迭代器耗尽时停止(以短为准)。zip 常用于并行遍历两个集合、数据配对、向量运算和差异比较。多个迭代器可以链式 zip,但需要嵌套解构。unzip() 是 zip 的逆操作,将元组迭代器拆为两个集合。enumerate() 本质上就是 (0..).zip(iter) 的语法糖。zip 不要求两个迭代器的元素类型相同。