JavaScript不修改原数组的排序实现方法

作者:异步漫步时间:2026-11-19 22:28:56浏览:523

深入解析 JavaScript 中不改变原数组的数组排序实现方案。涵盖 ECMAScript 2023 新增的 toSorted 原生方法、展开运算符与 slice 浅拷贝排序方案,并深度剖析原地修改机制、引用类型陷阱与多场景选型建议。

在 JavaScript 中,原生的 Array.prototype.sort() 会采取原地重排(In-place)策略直接改动原数组的内容。若要保留原数据完整性并生成排好序的新数组,当前最推荐的标准方案是使用 ECMAScript 2023(ES14)正式支持的 arr.toSorted() 方法;而在需要兼顾旧版本浏览器或兼容性考量的项目中,通常采用“先浅拷贝再排序”的经典范式,如 [...arr].sort() 或 arr.slice().sort()。本文将具体阐述这两种路径的用法、运行机制、适用场景以及对象元素浅拷贝排序时的注意事项。

JavaScript不修改原数组的排序实现方法
图 0:JavaScript 不可变排序核心逻辑 —— 保护原数组状态并派生有序新实例

一、为什么默认的 sort() 会修改原数组?

JavaScript 数组原型上的 sort() 方法早在 ECMAScript 规范初期就已确立。为了在早期的低内存环境中获取最高的空间利用率,其规范被设计为就地算法(In-place Algorithm)。调用 arr.sort() 时,JavaScript 引擎(如 V8)会直接在原数组占用的内存空间中重新排列元素位置,其返回值并不是新创建的副本,而是原数组本身的内存引用:

const original = [30, 10, 20];
const result = original.sort((a, b) => a - b);

console.log(original); // 输出: [10, 20, 30](原数组顺序已被破坏)
console.log(result === original); // 输出: true(返回的是同一引用)

在现代 Web 应用架构(例如 React、Vue、Pinia 或 Redux)中,数据的不可变性(Immutability)是状态管理与视图响应式更新的基础。如果某个函数在视图层内调用了 sort(),可能会产生以下隐蔽问题:

  • 组件渲染丢失:React 的状态比对依赖浅层引用比较(prev !== next)。就地修改数组不会改变指针地址,导致状态钩子认为数据未发生变化,从而跳过必要的 DOM 重新渲染。
  • 不可预期的状态污染:若该数组同时被其它组件或业务逻辑引用,就地修改会无声息地改变远端依赖的原始数据,引发难以排查的数据竞态与回溯异常。
JavaScript不修改原数组的排序实现方法
图 1:原地重排(In-Place)与副本隔离(Copy-on-Sort)在内存堆中的流转对比

二、现代官方方案:使用 toSorted() 原生方法

针对 sort() 长期以来的修改副作用,ECMAScript 2023(ES14)正式向标准库引入了一组“通过副本修改数组”(Change Array by Copy)的提案,其中专门用来实现不可变排序的方法即为 Array.prototype.toSorted()。

1. 基本语法与调用方式

toSorted() 的传参与规则与原有的 sort() 完全相同,唯一的根本区别在于:它在执行排序前会自动在堆内存中开辟一个新的数组实例,完成排序后返回该新实例,原数组的元素与索引保持原样不动。

const scores = [88, 95, 72, 64];

// 使用 toSorted 进行升序排列
const sortedScores = scores.toSorted((a, b) => a - b);

console.log(sortedScores); // 示例输出: [64, 72, 88, 95]
console.log(scores);       // 示例输出: [88, 95, 72, 64] (原数组未改变)
console.log(sortedScores === scores); // 输出: false (生成了独立的新引用)
⚠️ 必须提供自定义比较函数
与 sort() 一致,如果不传入比较函数,toSorted() 默认会将每个元素转为字符串后按照 UTF-16 码元顺序排列。例如 [10, 2, 5].toSorted() 的结果会是 [10, 2, 5](因为 "10" 的首字符在 "2" 之前)。进行数值大小排序时,务必显式传入 (a, b) => a - b。

2. 运行时兼容性与支持

toSorted() 已在主流现代运行时中获得全面支持:

  • 浏览器环境:Chrome 110+、Edge 110+、Firefox 115+、Safari 16.0+。
  • 服务端环境:Node.js 20.0.0+、Deno 1.31+、Bun 0.6.0+。

如果项目需要在更低版本的环境(如 Node.js 18 或老旧移动端 WebView)中运行,且希望统一语法标准,可以通过引入 core-js 提供的 Polyfill 实现向前兼容。

JavaScript不修改原数组的排序实现方法
图 2:安全实现不可变排序的 3 步标准化操作流程

三、通用兼容方案:浅拷贝后执行 sort()

在不支持 toSorted() 的构建环境或需要兼顾更老版本运行时的项目中,“先拷贝出独立副本、再对副本调用 sort()”是业界长期验证的标准模式。这本质上也是 toSorted() 在底层所做事情的手动实现。

方法 1:展开运算符(Spread Operator)—— 现代工程首选

基于 ES6 展开语法的 [...arr] 可以快速克隆一个浅拷贝新数组,随后链式调用 sort():

const list = [50, 12, 38, 9];

// 先通过展开语法生成副本,再就地排序副本
const sortedList = [...list].sort((a, b) => a - b);

console.log(sortedList); // 示例输出: [9, 12, 38, 50]
console.log(list);       // 示例输出: [50, 12, 38, 9] (原数组未被修改)

这种写法语法简短、语义明确,在日常 React、Vue 开发中被极为普遍地采用。

方法 2:Array.prototype.slice() —— 经典兼容方案

调用不带参数的 arr.slice() 会返回从索引 0 到末尾的浅拷贝切片。该方法自 ECMAScript 3 时代起就已存在,拥有 100% 的宿主环境覆盖度:

const originalArr = ["banana", "apple", "cherry"];

// 使用 slice() 产生切片副本后排序
const sortedArr = originalArr.slice().sort((a, b) => a.localeCompare(b));

console.log(sortedArr);   // 示例输出: ['apple', 'banana', 'cherry']
console.log(originalArr); // 示例输出: ['banana', 'apple', 'cherry']

在编写需兼容老版本运行时的基础通用类库(SDK)或打包目标受限时,arr.slice().sort() 是最稳妥的零依赖选择。

方法 3:Array.prototype.concat()

调用 arr.concat() 不传参数同样会返回一个包含所有原元素的新数组:

const sortedConcat = arr.concat().sort((a, b) => a - b);

虽然功能上与 slice() 类似,但从代码表达意图来看,concat 的本意为数组拼接,用其克隆数组语义相对不够直观,现代代码中更倾向使用 toSorted() 或展开语法。

JavaScript不修改原数组的排序实现方法
图 3:对象数组排序中的浅拷贝特性与堆内存引用共享模型

四、不可忽视的细节:浅拷贝与引用类型陷阱

无论是 toSorted()、[...arr] 还是 arr.slice(),它们所构建的副本都属于浅拷贝(Shallow Copy)。这带来了一个在复杂业务开发中容易被忽略的边界问题:

1. 引用类型元素依然共享内存地址

浅拷贝仅仅复制了第一层数组容器内的指针索引,如果数组的元素是普通对象(Object)或嵌套数组,原数组和新数组对应位置的元素依然指向堆内存中的同一个物理对象。

这就意味着:通过上述方法排序后,新数组的元素顺序发生了改变,这不会影响原数组的顺序;但如果后续代码改动了排序后新数组中某个对象的属性,原数组内部的对象属性也会随之改变:

const users = [
  { id: 1, name: "Alice", score: 80 },
  { id: 2, name: "Bob", score: 95 }
];

// 浅拷贝排序
const sortedUsers = users.toSorted((a, b) => b.score - a.score);

// 调整对象属性
sortedUsers[0].name = "Robert";

// 警惕:原数组中的对应对象也同步改变了!
console.log(users[1].name); // 示例输出: "Robert"
💡 彻底解耦的方案:深拷贝后再排序
如果你的排序结果不仅用于展示次序,后续还需要对内部对象进行编辑修改,并且绝不能波及原数组,则必须在排序前执行深拷贝(Deep Clone)。现代 JavaScript 环境中推荐直接调用原生标准函数 structuredClone:
const fullyIsolated = structuredClone(users).sort((a, b) => b.score - a.score);

2. 稀疏数组(Sparse Arrays)的处理差异

当数组包含空洞(如 const sparse = [3, , 1])时,不同拷贝方式的行为略有细微不同:

  • toSorted() 会将未赋值的空洞(Holes)转换为 undefined,并按照规范将所有的 undefined 统统移至排序结果的末尾,生成一个密集型数组(Dense Array)。
  • [...arr].sort() 同样会将展开后的空位转化为 undefined。
  • arr.slice().sort() 则会严格遵循老式 sort() 规范,保留稀疏槽位。在绝大多数常规业务开发中,将空洞密集化为 undefined 更符合类型一致性预期。
JavaScript不修改原数组的排序实现方法
图 4:JavaScript 不修改原数组排序方案综合比对与决策树

五、方案横向对比与技术选型指南

为了在实际项目开发中快速做出合理决策,下表总结了各常见实现方案的核心特性与适用条件:

实现方案 规范版本 核心优势 潜在限制 / 注意事项 典型适用场景
arr.toSorted(cmp) ES2023 (ES14) 标准原生支持,意图最明确,代码干净无需语法技巧。 老版本宿主(Node < 20,老版移动端)需 polyfill。 现代前端工程、Node 20+ 服务端开发。
[...arr].sort(cmp) ES2015 (ES6) 语法简练,主流前端工程(Babel/Vite/Webpack)标配。 属于浅拷贝,复杂对象修改需配合深拷贝。 React / Vue 组件内状态派生与日常业务开发。
arr.slice().sort(cmp) ES3 / ES5 极致兼容性,执行开销小,无任何依赖与转译负担。 代码语义不如 toSorted() 直观。 开源通用 SDK、老旧浏览器支持、性能敏感底层模块。
arr.concat().sort(cmp) ES3 / ES5 兼容性全覆盖。 语义偏差较大,容易被混淆为连接多个数组。 遗留系统维护,新项目一般不推荐。

选型结论:在日常现代化项目开发中,如果运行环境可控或已配置现代编译链路,优先使用原生的 arr.toSorted();在广泛的 React/Vue 业务开发中,[...arr].sort() 也是成熟且高读写效率的通用选择;当涉及对嵌套对象属性的后续修改时,始终牢记配合 structuredClone() 消除引用副作用。

作者最新文章
相关文章
更多