数组四个新方法实测:toSorted 只快 10%,还会把稀疏数组的空洞填成 undefined

举报
yd_250310792 发表于 2026/11/18 05:11:00 2026/11/18
【摘要】 ES2023 的 toSorted / toReversed / toSpliced / with 在 Node 22 全都能用,实测 100 万个数排序比 [...arr].sort() 省 30 毫秒(约 10%),20 万对象上反而更慢;真正的差别在语义:默认仍按字符串排序,稀疏数组的空洞会被填成真实的 undefined,with 越界直接抛 RangeError。

上周排查一个线上问题,翻到一行很普通的排序代码:`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 毫秒,说实话,在任何真实接口的耗时里都量不出来。

【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。