我所理解的 JavaScript 最佳实践(4):不用 reduce
- 使用现代化工具
- 尽量去掉只用一次的中间变量
- 遍历的起点决定按 ID 取数的顺序
- 不用 reduce(当前)
- 按遍历任务选择循环和数组方法
- 异步遍历按任务依赖选择并发或串行
- 卫语句让主流程保持平直
- 用函数给可复用的业务规则命名
- 让顺序无关的代码按名称排列
- 正确写注释
- 一行代码只做一件事
- 给函数起合适的名字
- 用空值合并运算符更好地控制默认值生效逻辑
- 用队列串行处理偏好更新,避免修改互相覆盖
- 确认弹窗关闭时,让等待中的 Promise 得到结果
- 用独立的预期值捕获实现错误
- 控制文件行数
- 控制函数圈复杂度和认知复杂度
- 使用工具函数进行类型判断
- 会演进的函数用对象参数
- 使用改进的原生 API
- 使用模板字符串优化多行文字展示
- 用查表取值,用 switch 分派动作
- 正确使用纯函数和副作用
- 避免数组空位
- 把条件写在可选元素和字段旁边
- 让独立条件各自表达
采集进度页拿到一组任务,每条记录有状态和条数。为了显示已经采集的记录总数,可以先选出完成的任务,再把每条任务的条数相加。
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 }), {});
按结果选择专门的写法
接手一段 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 直接计数。若调用方依赖字典的原型,也要单独确认工具函数的返回值。
一次拿到符合条件和不符合条件的两组
两组都要用时,可以用 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,并写清初值和顺序如何影响结果。