商品列表做价格从低到高排序,代码很顺手:list.sort((a, b) => a.price - b.price),没问题。但另一个页面按销量排,写成了 list.sort(),结果 10 排在 2 前面,运营看着后台数据觉得系统坏了。
这不是 bug,是 sort() 的默认行为:不传比较函数时,它把元素转成字符串,按字典序比。字符串里 "10" 的第一个字符是 1,比 "2" 小,所以排在前面。数字数组、价格、数量、时间戳,只要排序就必须传比较函数。
这篇讲什么:数组方法不难记,难在两件事——哪些方法会改原数组、哪些不会;以及每个方法「返回什么」。这两件搞混,就会出现「调了 filter 但原数组没变」或者「本来只想取前三个,结果原数组被删了」这类问题。读完你能做到:处理列表时选对方法;知道 sort 和 splice 会改原数组,需要时先复制;写出能看懂的链式处理。
先记住:哪些会改原数组
这是最该先记的一张表。判断标准很简单:方法名听起来像「增删改」的,通常改原数组;听起来像「转换、筛选、查找」的,通常返回新数组或不返回数组。
| 会改原数组 | 不会改,返回新数组 | 返回单个值或其他 |
|---|---|---|
push / pop | map | find / findIndex |
shift / unshift | filter | some / every |
splice | slice | reduce |
sort / reverse | concat | includes / indexOf |
fill / copyWithin | toSorted / toReversed / toSpliced | join / length |
最后那一组 toSorted、toReversed、toSpliced 是新加的「不改原数组版本」,用起来更安全,但要确认目标浏览器支持情况,老项目里可能还跑不了。
真实场景里最常出事的两个:
// 1. 以为 filter 会改原数组
const list = [1, 2, 3, 4];
list.filter((n) => n > 2);
console.log(list); // [1, 2, 3, 4],原数组没动
const filtered = list.filter((n) => n > 2);
console.log(filtered); // [3, 4],要接住返回值
// 2. 以为 sort 会返回新数组
const sorted = list.sort((a, b) => b - a); // list 自己也被改了
console.log(list); // [4, 3, 2, 1]
sort 会连别人看到的数据一起改。排序前先 [...list].sort(...) 或 list.toSorted(...) 复制一份,是成本最低的防事故手段。复制也要分清浅和深。[...list] 和 list.slice() 都只复制第一层,里面的对象还是原来那些。列表里装的是订单对象时,排序不会改原数组的顺序,但你在新数组里改 item.amount,原数组里的同一条也会跟着变:
const source = [{ id: 1, qty: 2 }];
const copy = [...source];
copy[0].qty = 9;
console.log(source[0].qty); // 9,两个数组指向同一个对象
要连内部字段一起隔离,得用深拷贝。JSON.parse(JSON.stringify(source)) 能应付纯数据,但会把 Date 变成字符串、把 undefined 字段丢掉;structuredClone(source) 更完整,不过函数、DOM 节点这类东西它复制不了。1 万条订单、每条二十来个字段,做一次 structuredClone 通常在几十毫秒,放在渲染路径上每次刷新都做,就会卡。只在要改内部字段前复制一次。
map、filter、reduce:三个主力
这三个是列表处理的核心,先弄清它们的语义差别:
map:一对一转换
元素数量不变,每个元素换成另一个东西。适合「把接口数据转成页面需要的形状」,或者「取对象里的某个字段」。
filter:按条件留下
数量变少,元素本身不变。适合「筛选已支付订单」「去掉空值」。
reduce:揉成一个结果
把整个数组压成单个值,比如求和、分组、建索引。功能最强,也最容易写难懂。
const orders = [
{ id: 1, status: "paid", amount: 120 },
{ id: 2, status: "pending", amount: 80 },
{ id: 3, status: "paid", amount: 60 }
];
// map:只要 id 列表
const ids = orders.map((o) => o.id);
console.log(ids); // [1, 2, 3]
// filter:只要已付款的
const paid = orders.filter((o) => o.status === "paid");
console.log(paid.length); // 2
// reduce:已付款的总金额
const total = paid.reduce((sum, o) => sum + o.amount, 0);
console.log(total); // 180
几个使用上的判断:
第一,map 的用途是「转换并返回」,不要拿它当 forEach 做副作用。下面这段代码能跑,但语义是错的,还会白建一个没人用的数组:
// 不推荐:map 的结果没人用
list.map((item) => {
saveToServer(item);
});
// 推荐:只是逐个执行,用 forEach 或 for...of
for (const item of list) {
saveToServer(item);
}
第二,filter 的回调要返回布尔值。返回其他东西时会被当成真假值,有时候碰巧对,有时候不对:
// 想筛出有库存的商品,stock 是数字
goods.filter((g) => g.stock); // 库存 0 也会被过滤掉,看起来对
goods.filter((g) => g.stock > 0); // 意图更明确
// 想筛出名字包含关键词的
goods.filter((g) => g.name.includes(keyword));
还有一个老坑:map 的回调会收到三个参数,分别是元素、下标、原数组。把现成的函数直接传进去时,多出来的参数会改变它的行为:
const nums = ["10", "20", "30"];
console.log(nums.map(parseInt)); // [10, NaN, NaN]
console.log(nums.map((s) => parseInt(s, 10))); // [10, 20, 30]
parseInt 的第二个参数是进制,map 把下标 1、2 传了进去,于是按 1 进制、2 进制解析,得到 NaN。传给 filter 的函数同理,第二个参数是下标。稳妥的做法是自己写箭头函数包一层,别把带额外参数的函数直接交给数组方法。
filter(Boolean) 常被用来去掉空值,但它去掉的不只是 null 和 undefined:
const values = [0, "", null, 5, false, "ok"];
console.log(values.filter(Boolean)); // [5, "ok"],0、空串、false 都没了
console.log(values.filter((v) => v != null)); // [0, "", 5, false, "ok"]
商品价格是 0 元的赠品、库存是 0 的缺货品,用 filter(Boolean) 会一起筛掉。只想排除 null 和 undefined,写 v => v != null,注意这里是双等号,能同时匹配两者。
第三,reduce 一定要给初始值。不给初始值时,空数组会直接抛 TypeError: Reduce of empty array with no initial value;不给初始值还会让第一次回调的参数变成数组前两项,逻辑容易写错:
// 分组:按状态归类
const grouped = orders.reduce((acc, order) => {
(acc[order.status] ??= []).push(order);
return acc;
}, {});
console.log(grouped);
// { paid: [订单1, 订单3], pending: [订单2] }
acc[order.status] ??= [] 这行是「没有这个键就先建个空数组」。第一次见到可能要想一下,拆开写就是 if (!acc[status]) acc[status] = []。团队里如果对这种写法不熟,拆开写更省沟通成本。
用普通对象当累加器还有个隐患:键来自外部数据时,__proto__ 这类键会碰到原型上的东西。订单状态一般可控,但如果是按用户输入分组,改用 Map 或 Object.create(null) 更稳:
const byTag = products.reduce((acc, p) => {
if (!acc.has(p.tag)) acc.set(p.tag, []);
acc.get(p.tag).push(p);
return acc;
}, new Map());
另外,别在 reduce 里用 acc = acc + item.name 拼长字符串。每拼一次都会新建一个字符串,1 万条就是 1 万次复制;先 push 进数组再 join("") 是线性复杂度。
查找和判断:find、some、every、includes
这几个方法都接收一个条件函数(includes 除外),区别在返回什么:
const users = [
{ id: 1, name: "张三", active: true },
{ id: 2, name: "李四", active: false }
];
users.find((u) => u.id === 2); // { id: 2, ... },找到第一个就停
users.find((u) => u.id === 9); // undefined
users.findIndex((u) => u.id === 2); // 1,找不到返回 -1
users.some((u) => u.active); // true,存在一个满足就算
users.every((u) => u.active); // false,全都满足才算
users.includes(users[0]); // true,按引用比较
// 判断某条记录是否存在,用 some 比 find 更符合语义
const exists = users.some((u) => u.id === 9); // false
经验上,find 找到就停,适合「我要这条数据」;some 适合「有没有」;every 适合「是不是全都」。判断存在却用 find 再判 undefined 也能跑,但读代码的人要多想一步。
includes 对对象数组基本没用,因为它比较的是引用。两个内容一样的对象,includes 也返回 false。要找对象,用 find 配合字段比较。
空数组上有两个容易误判的结果:[].every(...) 返回 true,[].some(...) 返回 false。前者是「全部满足」在空集上的默认定义,但拿它做权限校验会出事:用户一个权限都没有时,permissions.every((p) => user.has(p)) 反而放行。空列表要先单独判一下。
includes 用的是 SameValueZero 比较,[NaN].includes(NaN) 是 true,而 [NaN].indexOf(NaN) 是 -1;[1, 2, 3].includes("2") 是 false,它不会做类型转换。这跟 == 的宽松比较是两套规则,不要混着理解。
要找最后一个匹配项,用 findLast 和 findLastIndex;它们比 filter().at(-1) 省一次完整遍历,但出现得晚,老浏览器和旧 Node 上要先确认支持。拿不准就写倒序 for 循环,兼容性最稳。
sort:比较函数必须写,还要注意它改原数组
前面已经说了默认按字符串排序的问题。正确的写法是传一个比较函数:返回负数表示 a 排前面,正数表示 b 排前面,0 表示不动。
const prices = [30, 5, 100, 20];
prices.sort(); // [100, 20, 30, 5],按字符串比
prices.sort((a, b) => a - b); // [5, 20, 30, 100],升序
prices.sort((a, b) => b - a); // 降序
对象数组按字段排也一样:
const products = [
{ name: "A", price: 30 },
{ name: "B", price: 5 },
{ name: "C", price: 100 }
];
products.sort((a, b) => a.price - b.price);
console.log(products.map((p) => p.price)); // [5, 30, 100]
两个细节:一是 a.price - b.price 只适用于数字,字符串比较得用 localeCompare;二是比较函数必须「稳定」,别在里面写随机数或者改外部状态,否则排序结果可能不符合预期。老浏览器对排序稳定性没有保证,现在的主流引擎都稳定了,但依赖这个特性前最好确认目标环境。
按多个字段排,常见写法是连着排两次,依赖排序的稳定性:
const sorted = [...orders]
.sort((a, b) => a.amountCents - b.amountCents)
.sort((a, b) => Number(b.status === "paid") - Number(a.status === "paid"));
第二次排序只分「已支付」和「其他」,金额相同时保持上一次的顺序,所以已支付的单子里金额仍然从低到高。现代引擎的 sort 是稳定的,这段才成立;如果目标环境很老,或者不想依赖稳定性,就把两个条件写进同一个比较函数:先比状态,状态相同再比金额。
比较函数必须返回数字。写 (a, b) => a.price > b.price 返回的是布尔值,会被转成 1 或 0,永远没有负数,等于把「a 应该排前面」这种情况丢了,结果看着像排序,其实只完成了一半。拿不准就在比较函数里打印返回值,确认有负数、0、正数三种情况。
字段可能缺失时也要先兜底。接口返回的 priceCents 偶尔是 null,null - 100 得到 -100,这条记录会莫名跑到最前面;两边都是 null 时减法得到 NaN,顺序不可预测。比较前统一成 (a.priceCents ?? 0),或者把缺失项单独过滤出来。
toSorted 这类不改原数组的方法到 2023 年主流浏览器才陆续支持,Node 20 起才有。上线前用 typeof Array.prototype.toSorted === "function" 做一次特性检测,或者干脆统一写 [...arr].sort(),兼容性更好。
slice 和 splice:差一个字母,行为完全不同
const arr = ["a", "b", "c", "d"];
// slice:截取一段,返回新数组,不改原数组
arr.slice(1, 3); // ["b", "c"],含头不含尾
arr.slice(-2); // ["c", "d"]
console.log(arr); // ["a", "b", "c", "d"]
// splice:从原数组里删/加,返回被删掉的部分
const removed = arr.splice(1, 2);
console.log(removed); // ["b", "c"]
console.log(arr); // ["a", "d"],原数组变了
记忆方式:slice 是「切一片看看」,splice 是「动手术」。要复制数组用 slice() 或者 [...arr];要删除某一项,splice 是原地改,如果有别的引用,同样会影响到别人。
splice 还能用来插入,第二个参数传 0 就不删除任何东西:
const queue = ["a", "c", "d"];
queue.splice(1, 0, "b");
console.log(queue); // ["a", "b", "c", "d"]
删除某一项时不要用 delete arr[i]。它只把那个位置的值拿掉,数组长度不变,留下一个空位,JSON.stringify 出来是 null,forEach 还会跳过它。要么 splice,要么 filter 生成新数组。
在循环里边遍历边 splice 也是经典错误:删掉第 i 项后,后面的元素整体前移,下一次循环的 i 正好跳过了紧邻的那一项。要删多项,倒着循环 for (let i = arr.length - 1; i >= 0; i--),或者直接 filter 一次生成新数组。
还有一个不常被当成修改的操作:给 arr.length 赋一个更小的值会直接截断数组,赋更大的值会造出空位。这类代码在别人维护时很难看出来,尽量别用。
链式调用好看,但别硬凑
下面这段是常见的列表处理,读起来很顺:
const result = orders
.filter((o) => o.status === "paid")
.map((o) => ({ id: o.id, amount: o.amount }))
.sort((a, b) => b.amount - a.amount);
console.log(result);
// [ { id: 1, amount: 120 }, { id: 3, amount: 60 } ]
代价是它遍历了三次。十条数据无所谓,几万条就有感觉了。数据量大或者循环里还要做重活时,合并成一次 for...of 往往更快,也更好调试(能打断点、能 break)。
另一个常见问题是链式太长。超过三四步就该考虑抽成有名字的函数:
function getPaidOrderSummary(orders) {
return orders
.filter((o) => o.status === "paid")
.map((o) => ({ id: o.id, amount: o.amount }));
}
const summary = getPaidOrderSummary(orders).sort((a, b) => b.amount - a.amount);
名字本身就是注释,比在链式后面写一长串注释有用。
到底慢多少,别凭感觉,量一次。10 万条订单做 filter 加 map,每步只读字段,通常还在几十毫秒内;如果 map 里还要格式化日期、拼字符串,很容易翻几倍。用 console.time 包一下就能看到真实数字,比讨论「链式是不是性能差」有用。
链式还有个调试成本:回调里抛错时,调用栈里是一串匿名函数,定位不到是第几步。把关键步骤提成有名字的函数,报错信息里能看到名字;或者临时在每步后面打印一下长度,确认数据在哪一步变空。
内存上也要留意。10 万条数据做 filter 和 map,会各自留下一个中间数组,三个数组同时存在时,单是引用占用的内存大约各 0.8MB(每个元素一个指针按 8 字节算),对象本身才是大头。为了省这一次遍历,有时候不值得把代码写成难读的 for。
完整场景走查:今日大额订单面板
需求是运营提的:后台首页加一块「今日大额订单」,拉取当天已支付订单,按金额从高到低取前 10 条,展示订单号、用户名、金额,再显示这 10 条合计占当天已支付总额的比例。
接口是 GET /api/orders?date=2026-11-06&page=1&size=200,金额统一用「分」为单位的整数,返回结构大致这样:
{
"items": [
{
"orderNo": "SO20261106001",
"user": { "id": 1001, "name": "周敏" },
"amountCents": 129900,
"status": "paid",
"paidAt": "2026-11-06T09:12:31+08:00"
}
],
"totalPages": 4,
"total": 640
}
第一版写得很顺:
let orderCache = [];
async function loadOrders() {
const res = await fetch("/api/orders?date=2026-11-06&page=1&size=200");
const data = await res.json();
orderCache = data.items;
renderPanel();
}
function renderPanel() {
const top10 = orderCache
.sort((a, b) => b.amountCents - a.amountCents)
.filter((o) => o.status === "paid")
.slice(0, 10);
const paid = orderCache.filter((o) => o.status === "paid");
const totalCents = paid.reduce((sum, o) => sum + o.amountCents);
const topCents = top10.reduce((sum, o) => sum + o.amountCents, 0);
const ratio = ((topCents / totalCents) * 100).toFixed(1) + "%";
document.querySelector("#top10").textContent = top10
.map((o) => `${o.orderNo} ${o.user.name} ${(o.amountCents / 100).toFixed(2)}`)
.join(" | ");
document.querySelector("#ratio").textContent = ratio;
}
测试环境当天只有 37 单,页面完全正确,代码就上了。上线当天 640 单,四个问题一起冒出来。
第一,接口只取了第一页。640 单分 4 页,第一版只拿 200 条,按支付时间倒序,上午的大额订单根本没进来,前 10 和总额都偏小,占比反而显得很高。
第二,sort 原地改了 orderCache。同一页面还有个「最新订单」小列表也读这个缓存,刷新一次,那边的顺序就变成了按金额,不再按时间。两个模块谁也没改谁的代码,数据却被悄悄改了。
第三,当天没有已支付订单时(凌晨切日期、测试环境造空数据),reduce 没给初始值,直接抛 TypeError: Reduce of empty array with no initial value,整个首页白屏。
第四,状态枚举后来加了 settled(已结算),第一版只认 paid,结算完成的单子被漏掉,金额少了一截。
改法是四件事:把分页拉全、排序前复制、reduce 给初始值、用状态集合判断。
async function fetchAllPaidOrders(date) {
const all = [];
let page = 1;
let totalPages = 1;
do {
const res = await fetch(`/api/orders?date=${date}&page=${page}&size=200`);
if (!res.ok) throw new Error(`订单接口失败:${res.status}`);
const data = await res.json();
all.push(...data.items);
totalPages = data.totalPages;
page += 1;
} while (page <= totalPages);
const PAID_STATUS = new Set(["paid", "settled"]);
return all.filter((o) => PAID_STATUS.has(o.status));
}
async function renderPanel(date) {
try {
const paid = await fetchAllPaidOrders(date);
const top10 = [...paid]
.sort((a, b) => b.amountCents - a.amountCents)
.slice(0, 10);
const totalCents = paid.reduce((sum, o) => sum + o.amountCents, 0);
const topCents = top10.reduce((sum, o) => sum + o.amountCents, 0);
const ratio = totalCents === 0 ? "0.0%" : ((topCents / totalCents) * 100).toFixed(1) + "%";
document.querySelector("#top10").textContent = top10
.map((o) => `${o.orderNo} ${o.user.name} ${(o.amountCents / 100).toFixed(2)}`)
.join(" | ");
document.querySelector("#ratio").textContent = ratio;
} catch (err) {
document.querySelector("#top10").textContent = "加载失败,请稍后重试";
console.error(err);
}
}
这个改法在 640 单、4 次请求下能跑,串行请求按每次 120 毫秒算,多等 0.4 秒左右,可以接受。但如果当天有 2 万单、100 页,就不该让浏览器拉全量再算,应该让后端出一个 /api/orders/top?date=...&limit=10 的聚合接口,前端只取结果。数组方法不是不能算,是要先看数据量放在哪一端算。
错误现象对照
下面这些都是在订单、商品、报表这类列表代码里真实会碰到的现象。看到类似报错,先按第三列查,不要急着改逻辑。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
控制台报 TypeError: Reduce of empty array with no initial value | reduce 没传初始值,筛选结果又是空数组 | 看 reduce 的第二个参数,确认空列表也有兜底结果 |
合计金额显示 NaN,或出现 "120100" 这种拼接串 | 接口金额是字符串,+ 变成了字符串拼接;字段里还可能带货币符号 | 打印第一条原始记录的字段和 typeof,确认是数字再运算 |
| 刷新页面后,另一个列表的排序也变了 | sort 原地修改了多个组件共用的缓存数组 | 全局搜 .sort(,看调用前有没有复制 |
调用 filter 之后页面没变化,原数组长度也没变 | 没有接住返回值,filter 本来就不改原数组 | 看有没有 const next = list.filter(...),后续用的是不是 next |
| 删除列表项后,下一条数据被跳过,或者删错了行 | 循环里用 splice 边遍历边删,索引前移 | 看循环方向,改成倒序或先 filter 再赋值 |
| 排序结果大体对,但相等的元素顺序每次不同 | 比较函数返回布尔值或 undefined,没有稳定的负数和正数 | 在比较函数里打印返回值,确认是数字且覆盖三种情况 |
边界与代价
数组方法适合「几百到几万条、结构简单」的数据。
数据量在一千条以内,链式写法的可读性收益最大,性能基本不用考虑。到一万条,先量一次总耗时;如果这段代码在输入框里每次按键都跑,几十毫秒也会让输入变卡,这时候先做防抖,再谈换循环。到十万条以上,尽量只遍历一次,并且避免 [...arr] 这种整份复制:100 万个元素的引用复制一次大约 8MB,连着复制三份就是 24MB,手机上很容易触发内存压力。
这些场景不适合硬套数组方法:边遍历边删除,用倒序循环或 filter;去重不要用 filter 里套 includes,那是 O(n²),1 万条就要比一亿次,换 Set 是一遍;需要频繁在头部插入删除时,shift 和 unshift 每次都要搬整个数组,10 万条反复操作会明显变慢,考虑换成别的数据结构,或者改成从尾部操作。
稀疏数组也要小心。new Array(100) 造出来的是 100 个空位,map 和 forEach 都会跳过它们,回调一次都不执行;想要 100 个 0,写 Array.from({ length: 100 }, () => 0) 或 new Array(100).fill(0)。
不可变写法有代价。每次更新都复制一份数组,换来的是状态可追溯、对比容易;但如果列表几万条、又在一秒内更新十几次,复制和垃圾回收的开销会超过收益。列表稳定时不要为了「函数式」每次渲染都复制;真正需要响应式更新时,再按需复制并配合浅比较。
最后是维护成本。reduce 超过十五行、嵌套三四个三元表达式,读的人要来回翻;这种时候拆成 for...of 加几个有名字的中间变量,比炫技更有价值。
小结
push、splice、sort、reverse 会改,map、filter、slice、concat 不会。map 转换、filter 筛选、reduce 汇总,各司其职;map 不要拿来当 forEach 用。sort 一定传比较函数,数字用减法,字符串用 localeCompare;不想改原数组就先复制。for...of。把这几个练习在今天的工作里跑一遍,比读三遍文章管用:
- 在控制台分别执行
[10, 2, 33].sort()和[10, 2, 33].sort((a, b) => a - b),把两次结果记下来,解释第一个为什么不对。 - 准备一个 5 条订单的数组,先直接
sort,打印原数组;再用[...orders].sort(),对比两次原数组有没有变。 - 对一个空数组调用不带初始值的
reduce,把完整报错抄下来;再补上0,确认返回 0。 - 执行
["10", "20", "30"].map(parseInt),说出两个NaN的来源。 - 用
console.time量一下 10 万条对象的filter加map,记录耗时,判断你们的列表页要不要改写法。
下一篇讲this 与 class。数组方法里的回调经常和 this 扯上关系:goods.map(formatPrice) 如果 formatPrice 是某个对象的方法,里面的 this 就丢了;list.forEach(this.save) 也一样。那篇会讲清楚四种绑定规则、箭头函数怎么救场,以及 class 里的方法为什么更容易踩这个坑。