fold 消费器 ​

核心概念 ​

fold() 是迭代器的消费器方法,将迭代器中的所有元素"折叠"成一个最终值。它接受两个参数:一个初始值(累加器的起始值)和一个闭包。闭包有两个参数——当前的累加器值和当前元素——返回新的累加器值。每次迭代都用闭包的返回值更新累加器,最终返回累加器。fold 是一种通用的归约操作,sum()、product()、count() 等方法都可以用 fold 来实现。

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

    // 用 fold 求和:初始值 0,每次累加当前元素
    let sum = numbers.iter().fold(0, |acc, &x| acc + x);
    println!("总和: {}", sum);  // 15

    // 用 fold 求积:初始值 1,每次相乘
    let product = numbers.iter().fold(1, |acc, &x| acc * x);
    println!("乘积: {}", product);  // 120

    // fold 的执行过程:
    // fold(0, |acc, x| acc + x)
    // 第1次: acc=0, x=1 → 0+1=1
    // 第2次: acc=1, x=2 → 1+2=3
    // 第3次: acc=3, x=3 → 3+3=6
    // 第4次: acc=6, x=4 → 6+4=10
    // 第5次: acc=10, x=5 → 10+5=15
}

fold 的类型转换能力 ​

fold 的初始值类型和元素类型可以不同,这让 fold 可以将一种类型的集合归约为另一种类型。

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

    // Vec<&str> → String(拼接字符串)
    let sentence = words.iter()
        .fold(String::new(), |mut acc, &word| {
            if !acc.is_empty() {
                acc.push(' ');
            }
            acc.push_str(word);
            acc
        });
    println!("拼接: {}", sentence);

    // Vec<i32> → (i32, i32)(同时求最小和最大)
    let data = vec![5, 2, 8, 1, 9, 3, 7];
    let (min, max) = data.iter()
        .fold((i32::MAX, i32::MIN), |(min, max), &x| {
            (min.min(x), max.max(x))
        });
    println!("最小: {}, 最大: {}", min, max);

    // Vec<i32> → HashMap(按奇偶分组)
    use std::collections::HashMap;
    let nums = vec![1, 2, 3, 4, 5, 6, 7, 8];
    let grouped = nums.iter().fold(HashMap::new(), |mut map, &x| {
        let key = if x % 2 == 0 { "偶数" } else { "奇数" };
        map.entry(key).or_insert_with(Vec::new).push(x);
        map
    });
    println!("分组: {:?}", grouped);
}

fold 与 sum、product 的关系 ​

rust
fn main() {
    let nums = vec![1, 2, 3, 4, 5];

    // sum() 等价于 fold(0, |acc, x| acc + x)
    let sum1: i32 = nums.iter().sum();
    let sum2 = nums.iter().fold(0, |acc, &x| acc + x);
    println!("sum: {} == {}", sum1, sum2);

    // product() 等价于 fold(1, |acc, x| acc * x)
    let prod1: i32 = nums.iter().product();
    let prod2 = nums.iter().fold(1, |acc, &x| acc * x);
    println!("product: {} == {}", prod1, prod2);

    // count() 等价于 fold(0, |acc, _| acc + 1)
    let count1 = nums.iter().count();
    let count2 = nums.iter().fold(0, |acc, _| acc + 1);
    println!("count: {} == {}", count1, count2);

    // max() 可以用 fold 实现
    let max1 = nums.iter().max();
    let max2 = nums.iter().fold(None, |acc: Option<&i32>, x| {
        match acc {
            None => Some(x),
            Some(prev) => Some(if x > prev { x } else { prev }),
        }
    });
    println!("max: {:?} == {:?}", max1, max2);
}

fold 构建新集合 ​

rust
fn main() {
    // 用 fold 反转 Vec
    let data = vec![1, 2, 3, 4, 5];
    let reversed = data.iter().fold(Vec::new(), |mut acc, &x| {
        acc.insert(0, x);  // 每次插入到开头
        acc
    });
    println!("反转: {:?}", reversed);

    // 用 fold 去重
    let with_dups = vec![1, 3, 2, 3, 1, 4, 2, 5, 4];
    let unique = with_dups.iter().fold(Vec::new(), |mut acc, &x| {
        if !acc.contains(&x) {
            acc.push(x);
        }
        acc
    });
    println!("去重: {:?}", unique);

    // 用 fold 构建字符串表格
    let items = vec![("苹果", 5.0), ("香蕉", 3.5), ("橘子", 4.0)];
    let table = items.iter().fold(
        String::from("商品     价格\n--------+------\n"),
        |mut acc, (name, price)| {
            acc.push_str(&format!("{:<8} {:.1}\n", name, price));
            acc
        },
    );
    println!("{}", table);
}

fold 与 reduce 的对比 ​

rust
fn main() {
    let nums = vec![1, 2, 3, 4, 5];

    // fold:有初始值,空迭代器返回初始值
    let sum_fold = nums.iter().fold(0, |acc, &x| acc + x);
    println!("fold: {}", sum_fold);

    // reduce:没有初始值,用第一个元素做初始值
    // 空迭代器返回 None
    let sum_reduce = nums.iter().copied().reduce(|acc, x| acc + x);
    println!("reduce: {:?}", sum_reduce);

    // 空迭代器的区别
    let empty: Vec<i32> = vec![];
    let fold_result = empty.iter().fold(0, |acc, &x| acc + x);
    let reduce_result = empty.iter().copied().reduce(|acc, x| acc + x);
    println!("空fold: {}", fold_result);     // 0(返回初始值)
    println!("空reduce: {:?}", reduce_result); // None
}
特性foldreduce
初始值必须提供使用第一个元素
空迭代器返回初始值返回 None
返回类型初始值类型(可以和元素不同)Option<元素类型>
类型转换支持不支持

基本示例 ​

用 fold 实现一个统计分析器:

rust
#[derive(Debug)]
struct Stats {
    count: usize,
    sum: f64,
    min: f64,
    max: f64,
    sum_sq: f64,  // 平方和(用于计算方差)
}

impl Stats {
    fn new() -> Self {
        Stats {
            count: 0,
            sum: 0.0,
            min: f64::INFINITY,
            max: f64::NEG_INFINITY,
            sum_sq: 0.0,
        }
    }

    fn mean(&self) -> f64 {
        if self.count == 0 { 0.0 } else { self.sum / self.count as f64 }
    }

    fn variance(&self) -> f64 {
        if self.count == 0 { return 0.0; }
        let mean = self.mean();
        self.sum_sq / self.count as f64 - mean * mean
    }

    fn std_dev(&self) -> f64 {
        self.variance().sqrt()
    }
}

impl std::fmt::Display for Stats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "数量={}, 总和={:.1}, 平均={:.2}, 最小={:.1}, 最大={:.1}, 标准差={:.2}",
            self.count, self.sum, self.mean(), self.min, self.max, self.std_dev())
    }
}

fn main() {
    let scores = vec![85.0, 92.0, 78.0, 95.0, 88.0, 72.0, 91.0, 83.0, 97.0, 76.0];

    // 用 fold 一次遍历计算所有统计量
    let stats = scores.iter().fold(Stats::new(), |mut s, &x| {
        s.count += 1;
        s.sum += x;
        s.min = s.min.min(x);
        s.max = s.max.max(x);
        s.sum_sq += x * x;
        s
    });

    println!("成绩统计: {}", stats);

    // 用 fold 构建直方图
    let histogram = scores.iter().fold(
        std::collections::HashMap::new(),
        |mut map, &score| {
            let bucket = match score as u32 {
                90..=100 => "优秀",
                80..=89 => "良好",
                70..=79 => "中等",
                60..=69 => "及格",
                _ => "不及格",
            };
            *map.entry(bucket).or_insert(0) += 1;
            map
        },
    );

    println!("\n成绩分布:");
    for (grade, count) in &histogram {
        let bar = "#".repeat(*count);
        println!("  {:>4}: {} ({}人)", grade, bar, count);
    }

    // 用 fold 生成排名报告
    let mut sorted = scores.clone();
    sorted.sort_by(|a, b| b.partial_cmp(a).unwrap());

    let report = sorted.iter().enumerate().fold(
        String::from("排名报告:\n"),
        |mut acc, (i, &score)| {
            let medal = match i {
                0 => " [金]",
                1 => " [银]",
                2 => " [铜]",
                _ => "",
            };
            acc.push_str(&format!("  第{}名: {:.1}分{}\n", i + 1, score, medal));
            acc
        },
    );
    println!("{}", report);
}

常见问题 ​

问题一:fold 和 for 循环手动累加有什么区别?

功能等价。fold 更函数式、更紧凑,适合简单的归约操作。for 循环更灵活,适合复杂的控制流(如提前退出)。fold 不支持 break。

问题二:fold 可以提前终止吗?

标准的 fold 不能。如果需要提前终止,用 try_fold,它可以在闭包中返回 Err 或 None 来中断。

问题三:fold 的初始值类型必须和元素类型相同吗?

不需要。初始值可以是任何类型,这正是 fold 强大之处——可以将一种类型的集合归约为完全不同的类型。

问题四:fold 的性能怎么样?

和手写 for 循环一样。Rust 编译器会对 fold 做内联优化,没有额外开销。

适用场景 ​

  • 聚合计算:求和、求积、最值、平均值
  • 字符串拼接:将集合元素拼接为字符串
  • 类型转换:将集合归约为不同类型
  • 统计分析:一次遍历计算多个统计量

注意事项 ​

  • fold 是消费器,调用后迭代器被消耗
  • 初始值类型决定了返回值类型
  • fold 会遍历所有元素,不能提前终止(用 try_fold 代替)
  • 空迭代器的 fold 返回初始值
  • fold 的闭包接收 (累加器, 当前元素),返回新的累加器
  • reduce 是不需要初始值的版本

总结 ​

fold() 是迭代器的通用归约方法,接受初始值和闭包,将所有元素折叠成一个最终值。闭包参数是 (累加器, 当前元素),返回新的累加器值。fold 的初始值类型和元素类型可以不同,这让它能把一种类型的集合归约为任意类型。sum()、product()、count() 等方法都是 fold 的特殊情况。fold 总是遍历所有元素,需要提前终止时用 try_fold。reduce 是不需要初始值的变体,用第一个元素做初始值,空迭代器返回 None。