JS 清空数组的 4 种方法对比:性能与适用场景
对比 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 = []。
为什么清空数组不能只看“结果为空”?
很多初学者会觉得,只要执行之后打印数组看到 [],这几种写法就没有区别。实际上,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 种方法的具体表现就会非常清楚。
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 循环才有实际价值。
性能差异从何而来?如何在本地实测?
谈性能之前需要明确一个前提: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 个检查步骤走一遍就能确定唯一合理的写法,并在修改后快速验证是否符合预期:
| 方法写法 | 是否原地修改 | 支持 const |
性能与内存特征 | 适用场景 |
|---|---|---|---|---|
arr.length = 0 |
是(保留原引用) | 支持 | 不新建数组,原地截断,开销极低 | 缓存复用、共享队列清空、函数内部清空传入数组 |
arr = [] |
否(生成新引用) | 不支持 | O(1) 创建空数组,原数组视引用情况回收 |
需保留其他引用的快照、React 等不可变状态重置 |
arr.splice(0, arr.length) |
是(保留原引用) | 支持 | 会额外分配并返回包含全部旧元素的数组(O(n) 拷贝) |
清空的同时需要取出并处理被删除的全部元素 |
while (arr.length > 0) arr.pop() |
是(保留原引用) | 支持 | O(n) 循环调用,大数组下明显较慢 |
仅在逐个弹出元素时需同步执行特定清理操作 |
容易踩坑的 2 个常见细节
最后补充两个与清空数组直接相关、日常排查时容易绕弯的问题:
-
不要用
delete arr[i]来清空数组:delete只会把对应索引位置变为“空槽(empty)”,数组元素的总长度arr.length根本不会归零,后续使用forEach、map或读取length时都会产生稀疏数组相关的异常行为。 -
框架状态与普通缓存要分开处理:在 React 这类靠浅比较判断引用变化的视图库里,对状态数组直接写
items.length = 0后再传入原来的引用,组件不会触发重渲染,此时需要用新空数组setItems([]);而在自定义工具类、事件监听器列表或需要多处同步感知的缓存池中,则应当用items.length = 0保证引用一致。
普通函数和箭头函数在JavaScript中该怎么选?
2026-11-22 17:28:42
async/await是同步执行吗?澄清JS异步语法糖的误区
2026-11-22 16:23:09
JSP页面中怎么定义并调用JavaScript函数
2026-11-22 16:04:25
JS同步与异步执行的区别及事件循环中的表现
2026-11-22 14:55:44
JS正则验证数字时的常见陷阱:空字符串与特殊字符误匹配
2026-11-22 13:35:15








