fold 消费器
核心概念
fold() 是迭代器的消费器方法,将迭代器中的所有元素"折叠"成一个最终值。它接受两个参数:一个初始值(累加器的起始值)和一个闭包。闭包有两个参数——当前的累加器值和当前元素——返回新的累加器值。每次迭代都用闭包的返回值更新累加器,最终返回累加器。fold 是一种通用的归约操作,sum()、product()、count() 等方法都可以用 fold 来实现。
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 可以将一种类型的集合归约为另一种类型。
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 的关系
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 构建新集合
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 的对比
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
}| 特性 | fold | reduce |
|---|---|---|
| 初始值 | 必须提供 | 使用第一个元素 |
| 空迭代器 | 返回初始值 | 返回 None |
| 返回类型 | 初始值类型(可以和元素不同) | Option<元素类型> |
| 类型转换 | 支持 | 不支持 |
基本示例
用 fold 实现一个统计分析器:
#[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。