商品列表做价格从低到高排序,代码很顺手:list.sort((a, b) => a.price - b.price),没问题。但另一个页面按销量排,写成了 list.sort(),结果 10 排在 2 前面,运营看着后台数据觉得系统坏了。

这不是 bug,是 sort() 的默认行为:不传比较函数时,它把元素转成字符串,按字典序比。字符串里 "10" 的第一个字符是 1,比 "2" 小,所以排在前面。数字数组、价格、数量、时间戳,只要排序就必须传比较函数。

这篇讲什么:数组方法不难记,难在两件事——哪些方法会改原数组、哪些不会;以及每个方法「返回什么」。这两件搞混,就会出现「调了 filter 但原数组没变」或者「本来只想取前三个,结果原数组被删了」这类问题。读完你能做到:处理列表时选对方法;知道 sort 和 splice 会改原数组,需要时先复制;写出能看懂的链式处理。

先记住:哪些会改原数组

这是最该先记的一张表。判断标准很简单:方法名听起来像「增删改」的,通常改原数组;听起来像「转换、筛选、查找」的,通常返回新数组或不返回数组。

会改原数组不会改,返回新数组返回单个值或其他
push / popmapfind / findIndex
shift / unshiftfiltersome / every
spliceslicereduce
sort / reverseconcatincludes / indexOf
fill / copyWithintoSorted / toReversed / toSplicedjoin / 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 valuereduce 没传初始值,筛选结果又是空数组看 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。

把这几个练习在今天的工作里跑一遍,比读三遍文章管用:

  1. 在控制台分别执行 [10, 2, 33].sort() 和 [10, 2, 33].sort((a, b) => a - b),把两次结果记下来,解释第一个为什么不对。
  2. 准备一个 5 条订单的数组,先直接 sort,打印原数组;再用 [...orders].sort(),对比两次原数组有没有变。
  3. 对一个空数组调用不带初始值的 reduce,把完整报错抄下来;再补上 0,确认返回 0。
  4. 执行 ["10", "20", "30"].map(parseInt),说出两个 NaN 的来源。
  5. 用 console.time 量一下 10 万条对象的 filter 加 map,记录耗时,判断你们的列表页要不要改写法。

下一篇讲this 与 class。数组方法里的回调经常和 this 扯上关系:goods.map(formatPrice) 如果 formatPrice 是某个对象的方法,里面的 this 就丢了;list.forEach(this.save) 也一样。那篇会讲清楚四种绑定规则、箭头函数怎么救场,以及 class 里的方法为什么更容易踩这个坑。