如何在 JavaScript 中清空数组？

清除现有数组 A 的方法：

方法一

（这是我对这个问题的原始答案）

A = [];

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

这也是最快的解决方案。

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

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

方法 2（作为 Matthew Crumley 的 suggested）

A.length = 0

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

方法 3（作为 Anthony 的 suggested）

A.splice(0,A.length)

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

方法 4（作为 tanguy_k 的 suggested）

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

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

表现

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

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

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

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

---

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

A.length = 0;

---

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

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

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

仅供参考 Map 和 Set 定义 clear()，将 clear() 也用于 Array 似乎是合乎逻辑的。

打字稿版本：

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/32 http://jsperf.com/array-destroy/152

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

---

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

A.splice(0, A.length);

---

现在有不少于 2739 票的答案具有误导性和不正确性。

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

说“A = [] 是答案”是无知且绝对不正确的。 [] == [] 是假的。这是因为这两个阵列是两个独立的个体对象，具有自己的两个身份，在数字世界中占据自己的空间，每个都独立。

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

你不会带来一个新的，就好像你已经完成了你被要求做的事情。

相反，您清空垃圾桶。

你不会用一个新的空罐子替换装满的罐子，也不会像 A = [1,2,3,4] 中那样从装满罐子的标签“A”并将其粘贴到新罐子上； A = [];

清空数组对象是最简单的事情：

A.length = 0;

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

此外，在罐子空之前，您无需手动清除垃圾！你被要求在一个回合内完全清空现有的垃圾，在罐子变空之前不要捡垃圾，如： while(A.length > 0) { A.pop();也不是，把你的左手放在垃圾桶的底部，用你的右手在顶部握住它，以便能够拉出它的内容，如： A.splice(0, A.length);

不，您被要求清空它：

A.length = 0;

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

---

性能测试：

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

a = []; // 37% slower
a.length = 0; // 89% slower
a.splice(0, a.length)  // 97% slower
while (a.length > 0) {
    a.pop();
} // Fastest

---

您可以将其添加到您的 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），我倾向于同意。请谨慎决定如何处理。

---

您可以轻松地为您创建一个函数，更改 length 甚至将其添加到 native Array 作为 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 函数，还有许多其他方法可以做到这一点，但最推荐的一种可能是更改长度。

正如我首先所说，您也可以原型 remove() 因为它是您问题的答案。您可以简单地选择上述方法之一并将其原型化为 JavaScript 中的 Array 对象，例如：

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

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

arr.remove(); //[]

---

关于 while;pop/shift 在答案和评论中的表现存在很多混淆和错误信息。 while/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 是清除数组的最快方法（不考虑 []，因为虽然它是最快的，但实际上并没有清除现有数组）。

---

如果您正在使用

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 之前的回答，第二种方法更快。

---

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

并称之为：array.clear();

---

如果您对内存分配感兴趣，您可以使用 this jsfiddle 之类的内容以及 chrome 开发工具的时间线选项卡来比较每种方法。您将需要使用底部的垃圾桶图标在“清除”阵列后强制进行垃圾收集。这应该为您选择的浏览器提供更明确的答案。这里的很多答案都是旧的，我不会依赖它们，而是像上面@tanguy_k 的答案那样进行测试。

（有关上述标签的介绍，您可以查看 here）

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

<html>
<script>
var size = 1000*100
window.onload = function() {
  document.getElementById("quantifier").value = size
}

function scaffold()
{
  console.log("processing Scaffold...");
  a = new Array
}
function start()
{
  size = document.getElementById("quantifier").value
  console.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);

我只是在我正在处理的一些代码上做到了这一点。它清除了阵列。

---

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

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()

---

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

const numbers = [1, 2, 3]

您不能重新签名：

numbers = []

您只能截断：

numbers.length = 0

---

https://i.stack.imgur.com/nChy7.png

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

length ：您可以设置 length 属性以随时截断数组。当您通过更改其长度属性来扩展数组时，实际元素的数量会增加。

pop() ：pop 方法从数组中删除最后一个元素并返回返回删除的值。

shift() : 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());
  }
};

新数组（） | [] 使用数组构造函数或数组字面量创建一个具有新内存位置的数组。 mainArr = []; // 一个新的空数组被寻址到 mainArr。 var arr = new Array('10'); // 数组构造函数 arr.unshift('1'); // 添加到前面 arr.push('15'); // 添加到末尾 console.log("添加后：", arr); // ["1", "10", "15"] arr.pop(); // 从末尾删除 arr.shift(); // 从前面移除 console.log("After Removing : ", arr); // ["10"] var arrLit = ['14', '17']; console.log("数组字面量 « ", indexedItem( arrLit ) ); // {0,14}{1,17} 函数 indexedItem( arr ) { var indexedStr = ""; arr.forEach(function(item, index, array) { indexedStr += "{"+index+","+item+"}"; console.log(item, index); });返回 indexedStr; }

slice() ：通过使用 slice 函数，我们从原始数组中获取元素的浅表副本，并带有新的内存地址，因此对 cloneArr 的任何修改都不会影响到实际|原始数组。 var shallowCopy = mainArr.slice(); // 这是如何进行复制 var cloneArr = mainArr.slice(0, 3); console.log('Main', mainArr, '\tCloned', cloneArr); cloneArr.length = 0; // 清除数组的当前内存位置。 console.log('Main', mainArr, '\tCloned', cloneArr);

---

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

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);
    }
}

---