如何在JavaScript中清空数组？

有没有办法清空数组，如果可能的话，用.remove()？

例如， 

A = [1,2,3,4];

我怎么能清空它？

3761840 次浏览
小开
最佳答案

清除现有数组A的方法：

方法1

（这是我最初对这个问题的回答）

A = [];

此代码将变量A设置为一个新的空数组。如果您在其他任何地方都没有对原始数组#0的引用，这是完美的，因为这实际上创建了一个全新的（空）数组。您应该小心使用此方法，因为如果您从另一个变量或属性引用了此数组，原始数组将保持不变。仅当您仅通过其原始变量A引用数组时才使用此方法。

这也是最快的解决方案。

此代码示例显示了使用此方法时可能遇到的问题：

var arr1 = ['a','b','c','d','e','f'];var arr2 = arr1;  // Reference arr1 by another variablearr1 = [];console.log(arr2); // Output ['a','b','c','d','e','f']

方法2（建议 by马修·克拉姆利）

A.length = 0

这将通过将其长度设置为0来清除现有数组。有些人认为这可能不适用于所有JavaScript实现，但事实证明并非如此。在ECMAScript 5中使用“严格模式”时也有效，因为数组的长度属性是读/写属性。

方法3（建议 by安东尼）

A.splice(0,A.length)

使用.splice()将完美地工作，但由于.splice()函数将返回一个包含所有删除项的数组，因此它实际上会返回原始数组的副本。基准测试表明这对性能没有任何影响。

方法4（建议 bytanguy_k）

while(A.length > 0) {A.pop();}

这个解决方案不是很简洁，它也是最慢的解决方案，与原始答案中引用的早期基准相反。

性能

在清除现有数组的所有方法中，方法2和方法3在性能上非常相似，并且比方法4快得多。请参阅此基准。

正如Diadistis在下面的回答中指出的那样，用于确定上述四种方法性能的原始基准测试存在缺陷。原始基准测试重用了已清除的数组，因此第二次迭代正在清除一个已经为空的数组。

以下基准测试修复了此缺陷：http://jsben.ch/#/hyj65。它清楚地表明方法#2（长度属性）和#3（拼接）是最快的（不包括不会更改原始数组的方法#1）。

这一直是一个热门话题，引起了很多争议。实际上有很多正确的答案，因为这个答案已经被标记为可接受的答案很长一段时间了，我将在这里包括所有的方法。

小开

如果您需要保留原始数组，因为您有其他对它的引用也应该更新，您可以通过将其长度设置为零来清除它而无需创建新数组：

A.length = 0;
小开

一个更跨浏览器友好和更优化的解决方案是使用splice方法清空数组A的内容，如下所示：

A.splice(0, A.length);

小开

您可以将其添加到您的JavaScript文件中以允许您的数组被“清除”：

Array.prototype.clear = function() {this.splice(0, this.length);};

然后你可以像这样使用它：

var list = [1, 2, 3];list.clear();

或者如果你想确保你不会破坏一些东西：

if (!Array.prototype.clear) {Array.prototype.clear = function() {this.splice(0, this.length);};}

很多人认为您不应该修改本机对象（如Array），我倾向于同意。在决定如何处理这个问题时请谨慎。

小开 
Array.prototype.clear = function() {this.length = 0;};

并称其为：array.clear();

小开

这里最快的工作实现而保持相同的数组（“可变”）：

function clearArray(array) {while (array.length > 0) {array.pop();}}

仅供参考，它不能简化为while (array.pop())：测试将失败。

仅供参考地图和设置定义了clear()，数组也有clear()似乎是合乎逻辑的。

TypeScript版本：

function clearArray<T>(array: T[]) {while (array.length > 0) {array.pop();}}

对应测试：

describe('clearArray()', () => {test('clear regular array', () => {const array = [1, 2, 3, 4, 5];clearArray(array);expect(array.length).toEqual(0);expect(array[0]).toEqual(undefined);expect(array[4]).toEqual(undefined);});
test('clear array that contains undefined and null', () => {const array = [1, undefined, 3, null, 5];clearArray(array);expect(array.length).toEqual(0);expect(array[0]).toEqual(undefined);expect(array[4]).toEqual(undefined);});});

这里更新的jsPerf：http://jsperf.com/array-destroy/32http://jsperf.com/array-destroy/152

jsPerf离线。类似的基准测试：https://jsben.ch/hyj65

小开

使用1月最初建议的修改版本：

var originalLength = A.length;for (var i = originalLength; i > 0; i--) {A.pop();}

术语：

for (let i = A.length; i > 0;A.pop(),i--) {}

或者这里是另一个采取：

while(!A[Symbol.iterator]().next().done)A.shift()
小开

如果你对内存分配感兴趣，你可以使用这个jsfiddle和chrome开发工具的时间轴选项卡来比较每种方法。你会想使用底部的垃圾箱图标在“清除”数组后强制垃圾回收机制。这应该会给你选择的浏览器一个更明确的答案。这里的很多答案都是旧的，我不会依赖它们，而是像上面@tanguy_k的答案一样测试。

（有关上述选项卡的介绍，您可以在此处查看）

Stackoverflow强制我复制jsfiddle，所以这里是：

<html><script>var size = 1000*100window.onload = function() {document.getElementById("quantifier").value = size}
function scaffold(){console.log("processing Scaffold...");a = new Array}function start(){size = document.getElementById("quantifier").valueconsole.log("Starting... quantifier is " + size);console.log("starting test")for (i=0; i<size; i++){a[i]="something"}console.log("done...")}
function tearDown(){console.log("processing teardown");a.length=0}
</script><body><span style="color:green;">Quantifier:</span><input id="quantifier" style="color:green;" type="text"></input><button onclick="scaffold()">Scaffold</button><button onclick="start()">Start</button><button onclick="tearDown()">Clean</button><br/></body></html>

您应该注意，它可能取决于数组元素的类型，因为javascript管理字符串的方式与其他原始类型不同，更不用说对象数组了。类型可能会影响发生的事情。

小开

A.splice(0);

我刚刚在我正在处理的一些代码上执行了此操作。它清除了数组。

小开

性能测试：

http://jsperf.com/array-clear-methods/3

a = []; // 37% slowera.length = 0; // 89% slowera.splice(0, a.length)  // 97% slowerwhile (a.length > 0) {a.pop();} // Fastest
小开

如果您正在使用 

a = [];

然后你将新的数组引用分配给a，如果a中的引用已经分配给任何其他变量，那么它也不会清空该数组，因此垃圾收集器不会收集该内存。

对于前。 

var a=[1,2,3];var b=a;a=[];console.log(b);// It will print [1,2,3];

或

a.length = 0;

当我们指定a.length时，我们只是重置数组的边界，其余数组元素的内存将由垃圾收集器连接。

而不是这两种解决方案更好。

a.splice(0,a.length)

和

while(a.length > 0) {a.pop();}

根据kenshou.html的回答，第二种方法更快。

小开

在答案和评论中都有很多关于同时弹出/移位性能的混淆和虚假信息。同时/pop解决方案有（正如预期的那样）最差的表现。实际发生的情况是，设置对在循环中运行片段的每个示例只运行一次。例如：

var arr = [];
for (var i = 0; i < 100; i++) {arr.push(Math.random());}
for (var j = 0; j < 1000; j++) {while (arr.length > 0) {arr.pop(); // this executes 100 times, not 100000}}

我创建了一个正常工作的新测试：

http://jsperf.com/empty-javascript-array-redux

警告：即使在这个版本的测试中，你也看不到真正的区别，因为克隆数组占用了大部分测试时间。它仍然表明splice是清除数组的最快方法（没有考虑[]，因为虽然它是最快的，但实际上并没有清除现有的数组）。

小开

到目前为止，至少有2739票赞成的答案是误导和不正确的。

问题是：“如何清空现有数组？”例如A = [1,2,3,4]。

  1. 说“A = []是答案”是无知的，绝对不正确。[] == []是虚假。

    这是因为这两个数组是两个独立的，单独的对象，有自己的两个身份，在数字世界中占据自己的空间，每个人都有自己的空间。

假设你妈妈让你清空垃圾桶。

  • 你不会带来一个新的，好像你已经做了你被要求的事情。
  • 相反，你清空垃圾桶。
  • 你不会用一个新的空罐子代替装满的罐子，你也不会从装满的罐子上拿标签“A”，然后把它粘在新的罐子上，就像A = [1,2,3,4]; A = [];一样

清空数组对象是有史以来最简单的事情：

A.length = 0;

这样，“A”下的罐头不仅是空的，而且干净如新！

  1. 此外，你不需要手动移动垃圾，直到罐子是空的！你被要求清空现有的一个，完全，在一个回合中，不要捡垃圾，直到罐子是空的，如：

    while(A.length > 0) {A.pop();}

  2. Nor, to put your left hand at the bottom of the trash, holding it with your right at the top to be able to pull its content out as in:

    A.splice(0, A.length);

No, you were asked to empty it:

A.length = 0;

这是唯一正确清空给定JavaScript数组内容的代码。

小开

在此处输入图片描述

要清空数组的当前内存位置，请使用：'myArray.length = 0'或'myArray.pop() UN-till its length is 0'

  • #0：您可以随时设置长度属性来截断数组。当您通过更改其长度属性来扩展数组时，实际元素的数量会增加。
  • #0：pop方法从数组中删除最后元素并返回返回删除的值。
  • #0：Shift方法删除零点指数处的元素并将连续索引处的值向下移动，然后返回删除的值。

示例：

var arr = ['77'];arr.length = 20;console.log("Increasing : ", arr); // (20) ["77", empty × 19]arr.length = 12;console.log("Truncating : ", arr); // (12) ["77", empty × 11]
var mainArr = new Array();mainArr = ['1', '2', '3', '4'];
var refArr = mainArr;console.log('Current', mainArr, 'Refered', refArr);
refArr.length = 3;console.log('Length: ~ Current', mainArr, 'Refered', refArr);
mainArr.push('0');console.log('Push to the End of Current Array Memory Location \n~ Current', mainArr, 'Refered', refArr);
mainArr.poptill_length(0);console.log('Empty Array \n~ Current', mainArr, 'Refered', refArr);
Array.prototype.poptill_length = function (e) {while (this.length) {if( this.length == e ) break;
console.log('removed last element:', this.pop());}};

  • #0使用#1或#2创建具有新内存位置的数组。

    mainArr = []; // a new empty array is addressed to mainArr.
var arr = new Array('10'); // Array constructorarr.unshift('1'); // add to the frontarr.push('15'); // add to the endconsole.log("After Adding : ", arr); // ["1", "10", "15"]
arr.pop(); // remove from the endarr.shift(); // remove from the frontconsole.log("After Removing : ", arr); // ["10"]
var arrLit = ['14', '17'];console.log("array literal « ", indexedItem( arrLit ) ); // {0,14}{1,17}
function indexedItem( arr ) {var indexedStr = "";arr.forEach(function(item, index, array) {indexedStr += "{"+index+","+item+"}";console.log(item, index);});return indexedStr;}

  • slice() : By using slice function we get an shallow copy of elements from the original array, with new memory address, So that any modification on cloneArr will not affect to an actual|original array.

    var shallowCopy = mainArr.slice(); // this is how to make a copy
var cloneArr = mainArr.slice(0, 3);console.log('Main', mainArr, '\tCloned', cloneArr);
cloneArr.length = 0; // Clears current memory location of an array.console.log('Main', mainArr, '\tCloned', cloneArr);
小开

如果你使用常量，那么你别无选择：

const numbers = [1, 2, 3]

您不能重新签名：

numbers = []

您只能截断：

numbers.length = 0
小开

我很惊讶还没有人提出这个建议：

let xs = [1,2,3,4];for (let i in xs)delete xs[i];

这会产生一个与其他解决方案完全不同的数组。从某种意义上说，数组已“清空”：

xs=> Array [ <4 empty slots> ]
[...xs]=> Array [ undefined, undefined, undefined, undefined ]
xs.length=> 4
xs[0]=> ReferenceError: reference to undefined property xs[0]

您可以使用[,,,,]或Array(4)生成等效数组

小开

如果您需要清空Angular 2+FormArray，请使用下面的方法。 

public emptyFormArray(formArray:FormArray) {for (let i = formArray.controls.length - 1; i >= 0; i--) {formArray.removeAt(i);}}
小开

您可以轻松创建一个函数来为您执行此操作，更改长度甚至将其添加到原生数组作为remove()函数以供重用。

假设你有这个数组：

var arr = [1, 2, 3, 4, 5]; //the array

好的，只需运行这个：

arr.length = 0; //change the length

结果是：

[] //result

清空数组的简单方法…

也使用循环，这是不必要的，但只是另一种方式来做到这一点：

/* could be arr.pop() or arr.splice(0)don't need to return as main array get changed */
function remove(arr) {while(arr.length) {arr.shift();}}

你也可以考虑一些棘手的方法，例如这样的事情：

arr.splice(0, arr.length); //[]

因此，如果arr有5个项目，它将从0拼接5个项目，这意味着数组中没有任何内容。

还有其他方法，例如简单地重新分配数组：

arr = []; //[]

如果您查看Array函数，还有许多其他方法可以做到这一点，但最推荐的方法可能是更改长度。

正如我一开始所说的，你也可以原型删除（），因为它是你问题的答案。你可以简单地选择上面的方法之一，并将其原型化为JavaScript中的Array对象，类似于：

Array.prototype.remove = Array.prototype.remove || function() {this.splice(0, this.length);};

你可以简单地像这样调用它来清空javascript应用程序中的任何数组：

arr.remove(); //[]

提交答案