跳到正文

我所理解的 JavaScript 最佳实践(4):不用 reduce

我所理解的 JavaScript 最佳实践

  1. 使用现代化工具
  2. 尽量去掉只用一次的中间变量
  3. 遍历的起点决定按 ID 取数的顺序
  4. 不用 reduce(当前)
  5. 按遍历任务选择循环和数组方法
  6. 异步遍历按任务依赖选择并发或串行
  7. 卫语句让主流程保持平直
  8. 用函数给可复用的业务规则命名
  9. 让顺序无关的代码按名称排列
  10. 正确写注释
  11. 一行代码只做一件事
  12. 给函数起合适的名字
  13. 用空值合并运算符更好地控制默认值生效逻辑
  14. 用队列串行处理偏好更新,避免修改互相覆盖
  15. 确认弹窗关闭时,让等待中的 Promise 得到结果
  16. 用独立的预期值捕获实现错误
  17. 控制文件行数
  18. 控制函数圈复杂度和认知复杂度
  19. 使用工具函数进行类型判断
  20. 会演进的函数用对象参数
  21. 使用改进的原生 API
  22. 使用模板字符串优化多行文字展示
  23. 用查表取值,用 switch 分派动作
  24. 正确使用纯函数和副作用
  25. 避免数组空位
  26. 把条件写在可选元素和字段旁边
  27. 让独立条件各自表达

采集进度页拿到一组任务,每条记录有状态和条数。为了显示已经采集的记录总数,可以先选出完成的任务,再把每条任务的条数相加。

const total = jobs.filter(job => job.done).reduce((total, job) => total + job.count, 0);

读到 filter,我已经知道前半句是在筛选。读到 reduce,我还得看初始值是数字、数组还是对象,再找回调每轮返回什么。这里的两次 total 也表示不同东西,一个是最终结果,一个是走到当前任务前的小计。

import { sumBy } from 'es-toolkit';

const total = sumBy(
  jobs.filter(job => job.done),
  job => job.count,
);

现在函数名交代了动作,回调只交代从哪里取数。这也是我在业务代码里默认避开 reduce 的理由。读者一旦能从 API 名字看见动作,就可以把注意力放回字段和条件。

累加器同时藏了结果和过程

Array.prototype.reduce 的规范只约定如何传递累加器。每次回调得到上一步的结果,返回值再交给下一步。累加器可以是计数器、字典、数组、Promise,也可以是状态机。抽象足够通用,调用处就要承担解释这些含义的成本。

Unicorn 的 no-array-reduce 给了两条背景资料。可读性部分链接到 Jake Archibald 的讨论,性能部分链接到 Rich Snapp 对对象展开的分析。日常重构还可以参考 MDN 的 reduce 替换示例,其中按任务列出了 flat、flatMap、groupBy 和 Set 等写法。

例如,有人想把记录按 ID 建索引,用对象展开保留之前的键。第一个元素复制 0 个旧键,第二个复制 1 个。不同键持续增加时,旧键复制次数加起来是 0 + 1 + … + (n - 1),因此这一写法会有平方级的复制工作。Rich Snapp 在拆解 reduce 加对象展开时从 V8 的执行路径追到了这层隐藏遍历。普通的数字累加只做一次加法,不会因为用了 reduce 就变成平方级。

const byId = jobs.reduce((index, job) => ({ ...index, [job.id]: job }), {});

用三个不同 ID 建索引时,逐轮展开会重复复制旧字段,直接建索引只写入每个字段一次

按结果选择专门的写法

接手一段 reduce 时,先看它产出数字、布尔值、列表,还是按键组织的数据。以下示例使用普通密集数组。

求和与计数直接写明要累加的值

已有一组数就用 sum,从记录里取数就用 sumBy。后者把取值与普通加法放在同一轮遍历里。

import { sum, sumBy } from 'es-toolkit';

// 原写法
const total = values.reduce((total, value) => total + value, 0);
const records = jobs.reduce((total, job) => total + job.count, 0);

// 替代写法
const totalFromSum = sum(values);
const recordsFromSumBy = sumBy(jobs, job => job.count);

如果项目没有引工具库,三行循环就能把求和和初值交代清楚。

let finished = 0;
for (const job of jobs) {
  if (job.done) finished += job.count;
}

如果统计的是完成了多少个任务,每条记录只计一次,可以直接数过滤后的元素。只需要计数且列表很大时,用循环递增计数器可以省掉中间数组。

const finishedCount = jobs.reduce((count, job) => count + (job.done ? 1 : 0), 0);
const finishedCountFromList = jobs.filter(job => job.done).length;

极值按输入规模选择展开或循环

求极值时,小数组可以展开成参数。下面两种写法在空数组上分别保留 -Infinity 和 Infinity。数组很长时,用循环逐项更新极值,避免触及函数参数数量上限。

// 原写法
const max = values.reduce((best, value) => Math.max(best, value), -Infinity);
const min = values.reduce((best, value) => Math.min(best, value), Infinity);

// 替代写法
const maxFromValues = Math.max(...values);
const minFromValues = Math.min(...values);

查找与判断可以提前停止

只问「是否还有未完成的任务」时,找到一个就够了。some 到这里就会停止,reduce 即使已经累积出 true,也仍会调用后面已赋值元素的回调。

const hasPending = jobs.reduce((found, job) => found || !job.done, false);
const allDone = jobs.reduce((all, job) => all && job.done, true);
const firstPending = jobs.reduce((found, job) => found ?? (job.done ? undefined : job), undefined);

const hasPendingFromList = jobs.some(job => !job.done);
const allDoneFromList = jobs.every(job => job.done);
const firstPendingFromList = jobs.find(job => !job.done);

如果旧回调还负责逐项记日志或更新外部状态,改成提前停止的方法会少执行后面的副作用。各方法的停止位置和缺省结果可以对照第五篇的查找示例。

生成列表时看每个元素能产生几项

这种改法在社区里已有不少实例。YCM Jason 的一组数组处理对照把「每轮展开旧数组再追加元素」拆回 map、flatMap 和 filter。这三种写法各自暴露一项决定结果的业务规则,读者也能顺着函数名预期每条输入怎样进入输出。

// 原写法
const ids = jobs.reduce((result, job) => [...result, job.id], []);
const done = jobs.reduce((result, job) => (job.done ? [...result, job] : result), []);
const labels = labelLists.reduce((result, labels) => [...result, ...labels], []);

// 替代写法
const mappedIds = jobs.map(job => job.id);
const filteredJobs = jobs.filter(job => job.done);
const flattenedLabels = labelLists.flat();

例如,进度页只展示已完成任务的标签,并且一个任务可以有多个标签。每个输入返回标签数组或空数组,正好符合 flatMap 的输入形状。如果只是把现成的二维数组展开一层,用 flat() 就够了。

const labels = jobs.reduce((result, job) => (job.done ? [...result, ...job.labels] : result), []);
const visibleLabels = jobs.flatMap(job => (job.done ? job.labels : []));

去重按值或按键保留首项

标签按值去重,任务按 ID 去重。下面两组对照都保留首次出现的值或记录。标签是字符串,所以旧写法里的 includes 和新写法里的 Set 都能按值识别重复项。

import { uniqBy } from 'es-toolkit';

// 原写法
const uniqueLabels = labels.reduce((result, label) => (result.includes(label) ? result : [...result, label]), []);
const uniqueJobs = jobs.reduce((result, job) => (result.some(item => item.id === job.id) ? result : [...result, job]), []);

// 替代写法
const labelsFromSet = [...new Set(labels)];
const jobsFromUniqBy = uniqBy(jobs, job => job.id);

uniqBy 会跳过后面同键的记录。若业务要的是最后一次采集结果,可以用下节的索引写法覆盖旧值。

索引覆盖同键记录,分组和计数保留不同结果

// 原写法
const index = jobs.reduce((result, job) => ({ ...result, [job.id]: job }), {});

// 替代写法
const byId = Object.fromEntries(jobs.map(job => [job.id, job]));

这个表达式先把每条任务变成键值对,再用 Object.fromEntries 建索引。对象会把数字键转成字符串。要区分数字 1 和字符串 '1',可以用 new Map(jobs.map(job => [job.id, job])) 保留键的类型。两种索引都保留最后一条同键记录。按状态整理任务时,还要确定每个键的值是一条记录、一组记录,还是一个数字。

import { countBy } from 'es-toolkit';

// 原写法
const groups = jobs.reduce((result, job) => {
  (result[job.status] ??= []).push(job);
  return result;
}, Object.create(null));
const counts = jobs.reduce((result, job) => {
  result[job.status] = (result[job.status] ?? 0) + 1;
  return result;
}, Object.create(null));

// 替代写法
const byStatus = Object.groupBy(jobs, job => job.status);
const countByStatus = countBy(jobs, job => job.status);

Object.groupBy 返回无原型对象,分组键是字符串或 Symbol。要按对象身份分组,或区分数字键 1 和字符串键 '1',用 Map.groupBy。两种原生分组都要确认运行时支持。只需要每个状态的数量时,用 countBy 直接计数。若调用方依赖字典的原型,也要单独确认工具函数的返回值。

同一份任务列表,按状态分组得到任务列表,按状态计数得到数字,按 ID 去重保留首条

一次拿到符合条件和不符合条件的两组

两组都要用时,可以用 partition。它按布尔条件将输入分到两个数组,第一组是满足条件的元素。

import { partition } from 'es-toolkit';

// 原写法
const [finished, unfinished] = jobs.reduce(
  (groups, job) => {
    groups[job.done ? 0 : 1].push(job);
    return groups;
  },
  [[], []],
);

// 替代写法
const [doneJobs, pendingJobs] = partition(jobs, job => job.done);

拼接字符串和合并对象

把标签显示成一行时,先取出标签名,再用 join 放入分隔符。这样首项前、末项后都不会多出分隔符,空列表会得到空字符串。

const labels = tags.map(tag => tag.label);
const joined = labels.reduce((line, label, index) => (index === 0 ? label : `${line}、${label}`), '');

const line = tags.map(tag => tag.label).join('、');

如果原来用 reduce((merged, patch) => ({ ...merged, ...patch }), {}) 合并一组普通对象,每轮都会复制旧字段。对象数量有限,且键和值来自受控的普通数据时,可以用 Object.assign({}, ...patches) 做浅合并,后面的同名字段覆盖前面的字段。对象有 setter 或可能带有 __proto__ 等特殊键时,要检查赋值语义。字段需要深度合并时,也应先定义数组、缺失字段和冲突值怎么处理。

const merged = patches.reduce((result, patch) => ({ ...result, ...patch }), {});
const mergedOnce = Object.assign({}, ...patches);

串行异步任务用循环等待

有些保存操作要求按顺序提交,前一个失败就停止。用 Promise 当累加器可以写出这条链,也可以直接把等待放进循环。下面两种写法都假定 save 会返回代表本次保存的 Promise,调用方等整批完成后才继续。

await jobs.reduce((previous, job) => previous.then(() => save(job)), Promise.resolve());
for (const job of jobs) {
  await save(job);
}

这两种写法都在保存失败时停止启动后续任务。如果需求允许并发,可以参照第六篇的请求时间线选择等待方式。

多个结果依赖同一轮状态时,把步骤写出来

计算余额时,需要保留首次出现负数时的余额。旧写法可以跳过后续加法,但仍会走完回调。改成循环后可以直接在那个位置停止。以下两种写法都假定期初余额非负,变动列表只包含有限数。

const finalBalance = changes.reduce((balance, change) => (balance < 0 ? balance : balance + change), openingBalance);

let balance = openingBalance;
for (const change of changes) {
  balance += change;
  if (balance < 0) break;
}

有些场景的核心概念确实是「从初始状态反复应用转换」,例如事件回放用 events.reduce(applyEvent, initialState) 恢复状态。事件顺序、状态转换函数和初值都已有业务名字时,这句可以读成一个整体。团队开了限制规则,也可以为这个调用写明保留原因。

替换后用边界输入核对结果

这些对照以普通密集数组为前提。碰到稀疏数组,原生 reduce 会跳过空槽,数组的 for…of 会把空槽读成 undefined,工具函数也有自己的遍历约定。省略初值的 reduce 在空数组上会抛错,sum([]) 则返回 0。

对照时可以各取一条空输入和正常输入,再加一条最能体现业务规则的样本。建索引就放两个相同的键,查找就放两个能匹配的元素,串行任务就在中间放一次失败。这样能看出改写后保留了哪一项、何时停止,以及后续操作是否仍会执行。

Lint 先提醒,再按数据选写法

Unicorn 默认放过部分简单运算。希望在代码审查前看到这些调用,可以启用 unicorn/no-array-reduce,并把 allowSimpleOperations 设成 false。

import unicorn from 'eslint-plugin-unicorn';

export default [
  {
    plugins: { unicorn },
    rules: { 'unicorn/no-array-reduce': ['warn', { allowSimpleOperations: false }] },
  },
];

Unicorn 对某些简单求和会建议 Math.sumPrecise。在已有 es-toolkit 且求和对象是计数的项目里,更贴合代码意图的提示是 sum 或 sumBy。@sheng/eslint-plugin/unicorn 组合入口为已确认的数值求和提供这层提示,其他调用仍使用 Unicorn 的规则。两类诊断都沿用 unicorn/no-array-reduce,因此同一处调用只有一条提示,也可以用同一个 rule ID 关闭。

如果输入是大小相差悬殊的浮点测量值,换成普通求和工具可能无法改善逐步舍入。它属于另一类问题,可以看 Math.sumPrecise 能精确到哪一步 的两个对照实验。

总结

求和、查找、筛选和建索引都有能说清结果形状的 API。先按结果选名字,有多步状态变化或提前退出时就用循环。真正要表达状态折叠时,保留命名明确的 reducer,并写清初值和顺序如何影响结果。