JS 清空数组的 4 种方法对比:性能与适用场景

作者:纸飞机

时间:2026-11-22

浏览:486

对比 JavaScript 清空数组的 4 种常见写法(arr.length = 0、arr = []、arr.splice 和循环 pop),结合内存引用、const 限制、性能开销与开发场景说明各自适用边界。

文章目录

在 JavaScript 中清空一个数组,常见的写法有 4 种:修改 arr.length = 0、重新赋值为 arr = []、调用 arr.splice(0, arr.length),以及使用 while (arr.length > 0) { arr.pop(); } 逐个弹出。它们最终都能得到空数组,但在是否保留原数组引用、能否用于 const 声明、内存分配和执行开销上差别明显。一般场景下,需要保留原引用时优先用 arr.length = 0,希望断开旧引用或触发不可变状态更新时用 arr = []。

JS 清空数组的 4 种方法对比:性能与适用场景
图 0:清空数组的两种底层方向——重新绑定引用与原地清空实体

为什么清空数组不能只看“结果为空”?

很多初学者会觉得,只要执行之后打印数组看到 [],这几种写法就没有区别。实际上,JavaScript 中的数组是引用类型,变量里保存的并不是数组元素本身,而是指向堆内存中数组对象的引用。

如果代码里只有当前变量用到这个数组,修改引用和修改原数组看起来一样;一旦有第二个变量、对象属性、函数参数或闭包也指向同一个数组,两种清空方向就会产生截然不同的结果:

let listA = [1, 2, 3];
const listB = listA;

// 方式 1:只让 listA 指向一个新的空数组
listA = [];
console.log(listA); // 示例输出:[]
console.log(listB); // 示例输出:[1, 2, 3](未受影响)

// 方式 2:原地清空当前指向的数组
let listC = [1, 2, 3];
const listD = listC;
listC.length = 0;
console.log(listC); // 示例输出:[]
console.log(listD); // 示例输出:[](共享引用同步变空)

除了共享引用,是否使用 const 声明也会直接决定某种写法能不能跑通。理解这两层差异后,再看 4 种方法的具体表现就会非常清楚。

JS 清空数组的 4 种方法对比:性能与适用场景
图 1:重新赋值(arr = [])与原地清空(arr.length = 0)对共享引用的不同影响

4 种清空方法的写法、机制与边界条件

下面逐一拆解 4 种常用写法的工作方式。看每种方法时,建议同时留意三件事:是否改写原数组、是否产生额外数组分配、以及在什么条件下会失效。

方法 1:arr.length = 0(截断数组长度)

JavaScript 数组的 length 属性是可写的。当你把 arr.length 设为 0 时,引擎会按照 ECMAScript 规范直接移除索引大于等于 0 的元素,并将长度更新为 0。它修改的是数组对象本身,不会创建新数组,也不会改变变量引用。

const queue = ['task-1', 'task-2', 'task-3'];
const ref = queue;

queue.length = 0;

console.log(queue);       // 示例输出:[]
console.log(ref);         // 示例输出:[]
console.log(queue === ref); // 示例输出:true
适用边界:如果数组提前被 Object.freeze(arr) 冻结,或者通过 Object.defineProperty 把 length 设为不可写,再执行 arr.length = 0 在严格模式下会抛出 TypeError,非严格模式下会静默失败。另外,在依赖引用变化来触发更新的场景(如 React 的 useState)中,原地改长度不会生成新引用,不能直接替代 setItems([])。

方法 2:arr = [](重新赋值为新空数组)

这种写法并没有动原数组里的任何元素,而是新创建一个空数组字面量 [],再把变量指向这个新数组。如果原数组没有被其他变量、缓存或闭包引用,后续会由垃圾回收器(GC)回收;如果仍有其他地方引用旧数组,旧数据会完整保留。

let items = [10, 20, 30];
const snapshot = items;

items = [];

console.log(items);          // 示例输出:[]
console.log(snapshot);       // 示例输出:[10, 20, 30]
console.log(items === snapshot); // 示例输出:false
常见报错提醒:使用 const items = [10, 20] 声明的变量无法重新赋值,执行 items = [] 会抛出 TypeError: Assignment to constant variable.。同时,如果你把数组作为参数传进函数,在函数内对形参执行 param = [] 只会改写局部形参,调用方外层的原数组不会被清空。

方法 3:arr.splice(0, arr.length)(原地删除并返回旧元素)

splice() 会从索引 0 开始,原地删除 arr.length 个元素,因此它既能保留原数组引用,也能用于 const 声明的数组。但它与 arr.length = 0 有一个核心差异:splice() 会构造并返回一个包含所有被删除元素的新数组。

const buffer = ['a', 'b', 'c'];
const removed = buffer.splice(0, buffer.length);

console.log(buffer);  // 示例输出:[]
console.log(removed); // 示例输出:['a', 'b', 'c']

如果你的业务正好需要“一边清空当前队列,一边把刚取出的全部任务拿去批量处理”,splice(0, arr.length) 一次调用就能完成两件事。反之,如果你并不打算使用返回值,这份额外拷贝出来的数组就成了无意义的临时内存分配。

方法 4:while (arr.length > 0) { arr.pop(); }(循环弹出元素)

通过循环不断调用 pop() 每次移除末尾一个元素,直到长度为 0。它同样是原地修改、适用于 const,但每次循环都要进行条件判断、函数调用和长度减一操作,需要执行整整 n 轮。

const stack = [1, 2, 3];
while (stack.length > 0) {
  stack.pop();
}

console.log(stack); // 示例输出:[]
注意区分 pop() 和 shift():即便非要循环清空,也不要把循环体写成 arr.shift()。shift() 每次移除头部元素后,都需要把后面所有剩余元素整体前移一位,时间复杂度会从 O(n) 恶化为 O(n²),数据量大时很容易卡顿。常规清空场景一般不推荐写循环,只有当每个元素弹出时都必须顺带执行一段清理逻辑(例如 close(stack.pop()))时,while 循环才有实际价值。
JS 清空数组的 4 种方法对比:性能与适用场景
图 2:4 种清空数组写法的执行步骤、内存分配与复杂度来源对比

性能差异从何而来?如何在本地实测?

谈性能之前需要明确一个前提:JavaScript 代码的实际耗时高度依赖运行引擎(如 V8、SpiderMonkey、JavaScriptCore)、数组元素规模、元素类型(纯数字还是对象引用)以及即时编译(JIT)预热情况,因此不存在适用于所有设备的固定毫秒数字。不过,从各方法必须完成的工作量来看,它们之间的开销排序在多数现代引擎中都有稳定规律:

  • arr.length = 0 与 arr = [] 处于同一第一梯队:arr = [] 只分配一个新的空数组对象并改写引用,旧数组在没有外部引用时交给 GC 异步清理;arr.length = 0 直接缩减长度并清理原有槽位,省去了新建对象的步骤。如果一个数组会被高频反复填充和清空(例如动画帧缓冲或对象池),复用同一个数组配合 arr.length = 0 通常能减少短命对象的分配频率。
  • arr.splice(0, arr.length) 多了一次完整数组拷贝:哪怕你没有变量去接收返回值,规范层面 splice 仍需要构建并返回包含 n 个被删元素的数组。面对几百条数据差别不明显;当数组达到十万级以上时,这份额外的内存申请与 GC 压力会变得可感知。
  • while (arr.length > 0) arr.pop() 开销最大:数组越长,循环次数和函数调用次数就越多,单次清空大数组时往往明显落后于直接改写 length 或重新赋值。

如果你想结合自己的目标环境(比如浏览器端或 Node.js)确认具体表现,可以在浏览器开发者工具的 Console 面板或本地 Node.js 环境中运行下面这段对比脚本。为了减少单次偶然误差,示例对中等规模数组执行多轮填充与清空,并用 performance.now() 统计耗时:

function createSample(size) {
  const arr = new Array(size);
  for (let i = 0; i < size; i++) arr[i] = i;
  return arr;
}

function measure(label, fn, rounds = 50, size = 100000) {
  const pools = Array.from({ length: rounds }, () => createSample(size));
  const start = performance.now();
  for (let i = 0; i < rounds; i++) {
    fn(pools[i]);
  }
  const cost = performance.now() - start;
  console.log(`${label}: ${cost.toFixed(2)} ms`);
}

measure('length = 0', (arr) => { arr.length = 0; });
measure('reassign []', (arr) => { arr = []; });
measure('splice(0, len)', (arr) => { arr.splice(0, arr.length); });
measure('while pop', (arr) => { while (arr.length > 0) arr.pop(); });

// 示例输出(具体耗时随设备性能、Node/浏览器版本与数组规模而异):
// length = 0: 0.45 ms
// reassign []: 0.12 ms
// splice(0, len): 18.60 ms
// while pop: 32.40 ms

运行这类测试时要注意:reassign [] 在函数参数上只改写了局部变量,而真实业务里只有“需要保留原数组给其他引用”或“允许丢弃旧数组”时它才符合语义。性能测试必须在“语义正确”的前提下进行比较,不要为了微小的计时差距选用不符合引用需求的写法。

实际开发怎么选?判断步骤与对比清单

选型时不必死记硬背,按下面 4 个检查步骤走一遍就能确定唯一合理的写法,并在修改后快速验证是否符合预期:

JS 清空数组的 4 种方法对比:性能与适用场景
图 3:实际编码中检查约束、选择清空方式与验证结果的 4 个步骤
方法写法 是否原地修改 支持 const 性能与内存特征 适用场景
arr.length = 0 是(保留原引用) 支持 不新建数组,原地截断,开销极低 缓存复用、共享队列清空、函数内部清空传入数组
arr = [] 否(生成新引用) 不支持 O(1) 创建空数组,原数组视引用情况回收 需保留其他引用的快照、React 等不可变状态重置
arr.splice(0, arr.length) 是(保留原引用) 支持 会额外分配并返回包含全部旧元素的数组(O(n) 拷贝) 清空的同时需要取出并处理被删除的全部元素
while (arr.length > 0) arr.pop() 是(保留原引用) 支持 O(n) 循环调用,大数组下明显较慢 仅在逐个弹出元素时需同步执行特定清理操作
JS 清空数组的 4 种方法对比:性能与适用场景
图 4:JS 清空数组 4 种方法的选型决策路径总结

容易踩坑的 2 个常见细节

最后补充两个与清空数组直接相关、日常排查时容易绕弯的问题:

  • 不要用 delete arr[i] 来清空数组:delete 只会把对应索引位置变为“空槽(empty)”,数组元素的总长度 arr.length 根本不会归零,后续使用 forEach、map 或读取 length 时都会产生稀疏数组相关的异常行为。
  • 框架状态与普通缓存要分开处理:在 React 这类靠浅比较判断引用变化的视图库里,对状态数组直接写 items.length = 0 后再传入原来的引用,组件不会触发重渲染,此时需要用新空数组 setItems([]);而在自定义工具类、事件监听器列表或需要多处同步感知的缓存池中,则应当用 items.length = 0 保证引用一致。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章