数组四个新方法实测:toSorted 只快 10%,还会把稀疏数组的空洞填成 undefined
上周排查一个线上问题,翻到一行很普通的排序代码:`list.sort((a, b) => b.score - a.score)`。它把组件 props 里的数组排序了,父组件那份数据跟着变了,列表顺序在第二次渲染时整体错乱。改法只有一行——把 `sort` 换成 `toSorted`,问题消失。
顺手把这一组新方法都跑了一遍。它们是 ES2023 加的四个非破坏性数组方法:`toSorted`、`toReversed`、`toSpliced`、`with`,Node 20 起可用。我这台机器是 Node v22.22.2,四个都是原生函数,不需要 polyfill。
结论提前说:**它们的价值是语义,不是性能。** 想靠换方法提速,大概率会失望;想避免“顺手把别人的数据改了”,它们非常好用。
一、速度:只在两个场景赢
先看最常被问的那个问题——`toSorted` 是不是比 `[...arr].sort()` 快。
100 万个随机整数(0 到 99999),比较函数 `(a, b) => a - b`,先预热两轮再计时,7 轮取中位数:
```
[...arr].sort(cmp) 350.3 ms
arr.slice().sort(cmp) 346.4 ms
arr.toSorted(cmp) 319.7 ms
```
快了约 30 毫秒,10% 出头。但这个数字要打折看:三种写法各自的最好成绩都落在 313 到 317 毫秒之间,差距基本贴着测量噪声的边界。省下的那点时间来自少一次迭代拷贝,不是排序算法本身变快了——排序仍然占了绝大部分耗时。
20 万个对象(`{id, name}`,按 id 排)就更直接了:
```
[...objs].sort(f) 82.0 ms
objs.slice().sort(f) 83.4 ms
objs.toSorted(f) 84.1 ms
```
`toSorted` 反而慢了 2.6%,同样在噪声范围内。所以“新方法更快”这个印象,在对象数组上不成立。
小数组(100 个元素)也没有可测差异:8.20 微秒对 8.00 微秒。日常业务里绝大多数排序都在这个量级,纠结这个纯属浪费。
唯一能稳定赢的场景是链式调用。50 万个对象先 filter 再排序:
```
[...big.filter(o => o.id % 2 === 0)].sort(f) 224.1 ms
big.filter(o => o.id % 2 === 0).toSorted(f) 201.1 ms
```
省了一次中间数组的展开拷贝,快 11%。因为 `filter` 本来就返回新数组,再展开一次纯属多余——这时候 `toSorted` 是顺手省掉的。
二、默认排序还是按字符串来
这条坑和 `sort` 完全一样,但换了个名字之后更容易忘:
```js
[10, 9, 1].toSorted() // [1, 10, 9]
[10, 9, 1].toSorted((a,b)=>a-b) // [1, 9, 10]
```
数字数组不给比较函数,`10` 会排在 `9` 前面,因为元素被转成字符串比较。方法名里的“to”不会帮你做类型推断。
原数组确实不动,返回的是新引用(`===` 为 false),这一点比文档更值得记住:它意味着你可以放心把它接在 `map`、`filter` 后面,不用担心污染上游。
一个附带的收益是只读数组。`Object.freeze([3, 1]).sort()` 直接抛 `TypeError`,因为它要写回原数组;换成 `toSorted()` 就正常返回 `[1, 3]`。`Object.seal` 过的数组同理。以前处理冻结的配置表,得先手动拷一份再排,现在不用了。
三、三个真正会让你出错的细节
**第一个,稀疏数组的空洞会被填成真实的 undefined。** 这是四个方法里唯一会改变数据“形状”的地方,也是我这次实测才发现的:
```js
const a = [1, , 3];
Object.keys(a.slice().sort((x,y)=>x-y)) // ['0', '1'] 长度 3,空洞还在
Object.keys(a.toSorted((x,y)=>x-y)) // ['0', '1', '2'] 空洞变成了 undefined
```
`slice().sort()` 保留空洞(`2 in arr` 为 false),`toSorted()` 把空洞搬到末尾并填成真实元素(`2 in arr` 为 true,值就是 `undefined`)。两者 `JSON.stringify` 出来都是 `[1,3,null]`,肉眼看不出差别,但 `Object.keys().length`、`in` 判断、`map`/`forEach` 会不会跳过这一格,全都变了。如果你的数据来自 `new Array(n)` 预分配,或者后端返回的 JSON 里有 `[1, null, 3]` 这类结构,这个差异足够让下游的“跳过空值”逻辑静默失效。
**第二个,`with` 越界直接抛错,不做静默扩展。**
```js
[1, 2, 3].with(1, 9) // [1, 9, 3]
[1, 2, 3].with(-1, 9) // [1, 2, 9] 支持负索引
[1, 2, 3].with(3, 9) // RangeError: Invalid index : 3
```
下标等于长度就抛 `RangeError`,和 `arr[3] = 9` 那种“悄悄把数组撑长”的行为完全相反。这个设计是对的(`with` 语义是“替换某一项”),但如果你习惯用它来追加元素,就会在运行时炸掉。
**第三个,TypedArray 只支持一半。** `Uint8Array` 有 `toSorted`(返回的还是 `Uint8Array`,结果 `[1, 2, 3]`),但没有 `toSpliced`——`typeof u.toSpliced` 就是 `undefined`,调它直接报 not a function。二进制处理代码里混用这两个方法,会得到一个很难看的运行时错误。
另外 `toSpliced` 的负索引和 `splice` 一致,`[1,2,3,4].toSpliced(-2, 1, 'x')` 得到 `[1,2,'x',4]`。它返回新数组,原数组不变。
顺带一个不太常用但确实存在的特性:`toSorted` 是通用的,可以作用在类数组上——`Array.prototype.toSorted.call({length: 3, 0: 'b', 1: 'a', 2: 'c'})` 返回真正的 `['a','b','c']`。处理 `arguments` 或者自定义集合时能省一次转换,前提是别忘了默认的字符串排序。
四、怎么用:换不换,看你要不要留原件
我的判断标准很简单,一个问题就够:**排序之后,原始顺序还有用吗?**
如果没用——比如刚 `filter` 出来的临时数组、刚 `map` 出来的中间结果、函数内部自己造的数据——直接 `arr.sort()` 原地排,零拷贝最快,没必要换成 `toSorted`。
如果原始顺序必须保留——props 里的数组、store 里的 state、配置表、缓存里的数据——用 `toSorted`。它的价值不是快,是让你不必每次都想“我是不是该先拷一份”,也就不会再出现开头那种改一行代码把父组件数据弄乱的事故。
`toReversed` 的适用面比 `toSorted` 窄得多:`[...arr].reverse()` 已经足够直观,除非你在链式调用里想少一次展开。`with` 用在“只改一项”的场景很舒服,比如 React 里更新列表某一行的状态,比 `map` 加三元判断清爽。`toSpliced` 适合在不可变数据上做插入和删除。
总结
1. **性能别期待。** 100 万个数快 10%(350 → 320 毫秒),20 万对象反而慢 2.6%,小数组无差异。唯一稳定收益在链式调用里省一次展开拷贝(11%)。
2. **默认仍按字符串排序。** `[10,9,1].toSorted()` 得到 `[1,10,9]`,跟 `sort` 一模一样,数字数组必须传比较函数。
3. **稀疏数组是唯一的语义陷阱。** `toSorted` 会把空洞填成真实的 `undefined`,`slice().sort()` 会保留空洞;`JSON.stringify` 看不出区别,但 `in`、`Object.keys`、`map` 的行为全都变了。
4. **`with` 越界抛 `RangeError`,TypedArray 没有 `toSpliced`。** 这两个都属于“写的时候觉得没问题,跑起来才炸”的类型。
四个方法里我最常用的是 `toSorted`,理由跟性能无关,就是不想再为“这个数组是不是别人的”操心。而 `toSorted` 比 `[...arr].sort()` 快的那 30 毫秒,说实话,在任何真实接口的耗时里都量不出来。
- 点赞
- 收藏
- 关注作者
评论(0)