JavaScript Iterator Helpers 实战:重写数据管道,告别一堆中间数组

先看一段谁都能认出来的代码:

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 搞定,意图还更清楚。

JavaScript Iterator Helpers 实战:重写数据管道,告别一堆中间数组
收藏 (0) 打赏

感谢您的支持,我会继续努力的!

打开微信/支付宝扫一扫,即可进行扫码打赏哦,分享从这里开始,精彩与您同在
点赞 (0)

版权声明:
本站资源有的来自互联网收集整理,本站纯免费分享提供学习使用,如果侵犯了您的合法权益,请发送邮件1506151422@qq.com联系,将会及时下架删除。
本站资源仅供研究、学习交流之用,免费开源项目不代表完全可商用,若商业用途请先咨询开发企业能否商用,否则产生的一切后果将由下载用户自行承担。
原创板块未经允许不得转载,否则将追究法律责任。

淘吗网 javascript JavaScript Iterator Helpers 实战:重写数据管道,告别一堆中间数组 https://www.taomawang.com/web/javascript/3034.html

常见问题

相关文章

猜你喜欢
发表评论
暂无评论
官方客服团队

为您解决烦忧 - 24小时在线 专业服务