先看一段谁都能认出来的代码:
function recentErrors(logs) {
return logs
.filter(log => log.level === 'error')
.map(log => log.userId)
.filter(Boolean)
.slice(0, 20);
}
逻辑很清楚,但内存不这么想。假设 logs 有 20 万行、其中 3 万行是 error:第一个 filter 造一个 3 万长度的中间数组,map 再造一个 3 万长度的,第三个 filter 再来一个,最后 slice 留下 20 个,前面那三个数组全是垃圾。而我们真正需要的,只有前 20 个。
ES2025 把 Iterator Helpers 正式收了进来,就是来解决这个别扭的。同一段逻辑改成:
function recentErrors(logs) {
return logs.values()
.filter(log => log.level === 'error')
.map(log => log.userId)
.filter(Boolean)
.take(20)
.toArray();
}
全程不创建中间数组。取到第 20 条就停,剩下的 19 万多行压根没被遍历。这篇文章用一个真实的日志分析场景走一遍,把能踩的坑都踩一遍。
先确认你的运行时够不够新
Iterator Helpers 在 Chrome 122、Node 22、Safari 18.2、Firefox 131 之后都是默认开启的。一行命令就能验:
node -e "console.log(typeof [].values().map, typeof [].values().take)"
输出 function function 就说明可以直接用。如果拿到的是 undefined,先升运行时版本,或者引入 core-js 的 esnext.iterator.* polyfill。文章后面会讲降级策略。
为什么写 logs.values() 而不是 logs
这是第一次接触最容易迷糊的地方。Iterator Helpers 的方法挂在 Iterator.prototype 上,而数组本身不是迭代器,是”可迭代对象”。中间差一步转换。
logs.values() 拿到的是数组的 values 迭代器,它继承了 %IteratorPrototype%,所以能连上 filter / map / take。
也可以写成 logs[Symbol.iterator](),效果一样,但 .values() 短且好读。另外还有一个 Iterator.from(),专门用来把任意可迭代对象(包括第三方库返回的自定义迭代器)包装成带全套方法的迭代器,后面会用到。
把整条管道搬过去:一个真实的日志分析接口
场景是后台的”异常用户速览”:从最近的日志里筛出 error 级别、userId 不为空、且不在白名单里的记录,按用户去重,最多返回 15 个用户,附带这个用户最近一条错误时间。
老写法:
function getOversightUsers(logs, whitelist) {
const allow = new Set(whitelist);
return logs
.filter(log => log.level === 'error')
.filter(log => log.userId && !allow.has(log.userId))
.map(log => ({ userId: log.userId, at: log.time }))
.filter((item, index, arr) => arr.findIndex(x => x.userId === item.userId) === index)
.slice(0, 15);
}
这段代码里最贵的其实是倒数第二行:findIndex 套在 filter 里,复杂度直接退化到 O(n²)。三万条 error 日志,这里能跑出几百毫秒。
换成迭代器版本,顺手把去重逻辑挪到管道外面用 Set 处理:
function getOversightUsers(logs, whitelist) {
const allow = new Set(whitelist);
const seen = new Set();
return logs.values()
.filter(log => log.level === 'error')
.filter(log => log.userId && !allow.has(log.userId))
.filter(log => {
if (seen.has(log.userId)) return false;
seen.add(log.userId);
return true;
})
.map(log => ({ userId: log.userId, at: log.time }))
.take(15)
.toArray();
}
去重哈希表摊平了 O(n²),take(15) 命中 15 个用户就直接收工。map 放在 take 前面还是后面都行,但放后面少构造 14 个对象——不对,这里其实影响很小,因为 take 之后最多也就 15 条。真正有意义的是它会短路:第 15 个不同用户出现的那一刻,迭代就终止了。
用 console.time 在 20 万行日志上跑,老写法大概 300~500ms,迭代器版稳定在 20ms 以内,差距主要在去重那一步。这不是 Iterator Helpers 的功劳,但它让”边读边停”变成了默认行为,你自然就会把最贵的过滤往前排、最没用的事情干脆不做。
惰性求值到底省了什么
链式数组方法每一步都立即执行并产出结果;迭代器的每个环节都是”按需拉取”,上游只在被下游 next() 的时候才推进一步。
写个能亲眼看到的版本:
const range = {
*[Symbol.iterator]() {
let i = 0;
while (true) yield i++;
}
};
const doubled = Iterator.from(range)
.map(n => {
console.log('map:', n);
return n * 2;
})
.filter(n => n % 3 === 0)
.take(3)
.toArray();
console.log(doubled); // [0, 6, 12]
注意 range 是个无限序列,永远走不完。用数组链式方法写这行代码会直接把内存吃光,而这里 take(3) 一到就停。控制台会打印 map: 0 到 map: 9,因为满足条件的第 3 个数是 12,对应原始值 6,中间 map 只跑了 7 次(0~6),后面的无尽数字一个都没碰。
这个特性用在”翻页拉数据直到凑够”的场景里特别顺手:
async function* fetchPages(fetchPage) {
let cursor = null;
while (true) {
const { items, next } = await fetchPage(cursor);
yield* items;
if (!next) return;
cursor = next;
}
}
async function collectUserIds(fetchPage, userIds) {
const want = new Set(userIds);
const found = new Set();
for await (const row of fetchPages(fetchPage)) {
if (want.has(row.id)) found.add(row.id);
if (found.size === want.size) break;
}
return [...found];
}
注意这里用的是 for await...of 而不是 Iterator Helpers 链式调用。原因很简单:异步迭代器身上的 map / filter 是另一套东西(AsyncIterator.prototype),写法几乎一样,但不能和同步的混用。而且当管道里需要”查表 + 提前退出”这种带状态的逻辑时,老老实实写 for...of 加 break 反而更直白。
Set 方法:这次一起发布的另一块砖
ES2025 同批落地的还有 Set 的集合运算,做数据比对时能省掉不少 filter + has 手写循环:
const activeToday = new Set(['u1', 'u2', 'u3', 'u4']);
const subscribed = new Set(['u2', 'u4', 'u5']);
const banned = new Set(['u9']);
console.log([...activeToday.intersection(subscribed)]);
// ['u2', 'u4']
console.log([...activeToday.difference(subscribed)]);
// ['u1', 'u3']
console.log([...activeToday.union(subscribed)]);
// ['u1', 'u2', 'u3', 'u4', 'u5']
console.log(activeToday.isDisjointFrom(banned)); // true
console.log(subscribed.isSupersetOf(new Set(['u4']))); // true
把它们和迭代器管道接起来用,前面那个日志分析还能再短一点。比如需求变成”筛出今天活跃但没订阅、也不在封禁名单里的用户”:
const targets = activeToday
.difference(subscribed)
.difference(banned);
const rows = logs.values()
.filter(log => targets.has(log.userId))
.take(50)
.toArray();
difference 返回的仍然是 Set,可以继续链下去。targets.has 是 O(1),比在数组里 includes 快一个量级。
有个细节容易记混:union、intersection 这些方法都返回新的 Set,不修改原对象。而 add / delete 是原地修改的。混着写会出一些莫名其妙的 bug。
容易栽跟头的几个地方
迭代器是一次性的。 这是最多的翻车点:
const it = logs.values().filter(l => l.level === 'error');
console.log(it.toArray().length); // 30000
console.log(it.toArray().length); // 0,因为已经耗尽了
想复用就把结果存下来:const errors = it.toArray(),之后在数组上操作。别指望迭代器能像数组一样反复读。
回调里拿不到 index 和原数组。 这点和数组方法差别最大:
[10, 20, 30].filter((v, i) => {
console.log(i); // undefined
return true;
});
Iterator.prototype.filter 的回调只传当前值一个参数,map 也一样。需要索引就自己维护一个计数器,或者干脆先转成数组。写惯了数组方法的人在这里卡住会很郁闷,因为代码不报错,只是在 i 为 undefined 的时候悄悄走错分支。
没有 length,不能随机访问,console.log 也是一坨。 迭代器对象直接打印出来是个内部实现相关的结构,看不到内容。调试时先 .toArray() 再看,或者用 Array.from(it)。
小数组上反而更慢。 创建迭代器对象、包装 next 调用都是有成本的。一两百个元素的数组,老老实实 filter + map 更快。Iterator Helpers 的收益来自”数据量大”或者”能提前终止”,这两个前提都不满足时,它只是在炫技。
给个直观的对比脚本,自己跑一下心里就有数了:
const data = Array.from({ length: 1000 }, (_, i) => i);
console.time('array');
const a = data.filter(n => n % 2 === 0).map(n => n * 2).slice(0, 10);
console.timeEnd('array');
console.time('iterator');
const b = data.values().filter(n => n % 2 === 0).map(n => n * 2).take(10).toArray();
console.timeEnd('iterator');
把 1000 换成 10 万再看一次,结论会反过来。这个拐点大概在几千的量级,具体数字跟运行时和数据结构都有关,别把它当定律,自己测。
老项目怎么渐进接进来
直接在生产代码里写 .take(),遇上没升级的浏览器就是 is not a function。两个办法:
一是加 polyfill,core-js 里对应的是 esnext.iterator.map 这一系列模块,按需引入,不要整套 core-js/stable 全塞进去。
二是自己包一层,只在确认支持时才走迭代器路径:
const HAS_ITER_HELPERS =
typeof Iterator !== 'undefined' && typeof Iterator.prototype.take === 'function';
export function takeFirst(iterable, n) {
if (HAS_ITER_HELPERS) {
return Iterator.from(iterable).take(n).toArray();
}
const out = [];
for (const item of iterable) {
if (out.length >= n) break;
out.push(item);
}
return out;
}
注意这里用的是 Iterator.from(iterable) 而不是 iterable.values()。前者对数组、Set、Map、生成器、自定义可迭代对象都成立,后者只有数组和类型化数组才有。写通用工具函数时,Iterator.from 是更稳的入口。
另外,for...of 加 break 这个降级写法,其实和 Iterator Helpers 的语义完全一致——都在第一个满足条件的地方停下。如果你发现自己写的管道越来越长、条件越来越多,不如直接用 for...of 写循环,可读性和调试体验往往更好。工具是拿来省事的,不是拿来凑长度的。
写在最后
Iterator Helpers 最实在的价值不是”少写几行代码”,而是把”不必要的工作不做”变成了默认设置。过去的链式数组调用是”先全部算完,再挑前面几个”,现在顺序反了过来:下游要多少,上游才做多少。这个转变在处理日志、搜索结果、流式数据这类”量大但只需要一小部分”的场景里,收益是实打实的。
至于 Set 的那几个方法,属于那种用一次就回不去的类型。以前写集合交集要 filter(x => other.has(x)),现在一个 intersection 搞定,意图还更清楚。

