问：

这个问题的答案是社区的努力。编辑现有答案以改进这篇文章。它目前不接受新的答案或交互。

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

例如，

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

我怎样才能清空它？

huntsbot.com洞察每一个产品背后的需求与收益，从而捕获灵感

答1:

huntsbot.com – 高效赚钱，自由工作

清除现有数组 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，它不会改变原始数组）。

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

while (A.length) { A.pop(); }，不需要 > 0

> 0 恕我直言，更具可读性。两者之间没有性能差异。

@daghan，完全不清楚您要说什么。即使在 a 被分配了一个新数组之后，b 也会保留对旧数组的引用。 c 和 d 继续引用同一个数组。因此，预计会出现产出差异。

@DiegoJancic 方法 #1 不算数，因为它不会清除数组。它创造了一个新的。它不应该包含在基准测试中。

如果数组中的项目是假的，则不能使用 while(A.pop())。例如，A = [2, 1, 0, -1, -2] 将导致 A 等于 [2, 1]。甚至 while(A.pop() !== undefined) 也不起作用，因为您可以将未定义的数组作为值之一。可能是编译器没有优化它的原因。

答2:

一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

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

A.length = 0;

ECMAScript 5 标准对此有何评论？

@Pacerier：它仍然适用于 ES5。从第 15.4 节：“......每当更改长度属性时，名称为数组索引且值不小于新长度的每个属性都会自动删除”

@LosManos 即使在严格模式下， length 也是一个特殊属性，但不是只读的，所以它仍然可以工作。

@MattewCrumley 我做了一些测试，似乎 a.length = 0 不能有效地清除整个数组。 jsperf.com/length-equal-0-or-new-array 我认为，如果您有一个引用（并且您没有添加要保留的额外属性），最好创建新数组，并将旧数组留给垃圾收集器，以便在适当时运行。

@jollarvia ECMAScript 规范要求删除新长度以上的元素，因此任何正确的实现都会使任何不可访问的元素成为垃圾回收。这并不一定意味着他们会立即缩小实际阵列的存储空间。具体来说，V8 仅在新长度小于原始长度的一半时才重新分配数组，但将长度设置为零实质上是在幕后重新分配新数组。

答3:

huntsbot.com高效搞钱，一站式跟进超10+任务平台外包需求

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

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

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

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

打字稿版本：

function clearArray(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

TT您的答案是唯一正确且快速（同时）但“赞成票”少得多的答案。好吧，似乎人们喜欢很慢的漂亮解决方案：/

@naomik 但这是基本功能之一，默认情况下应该存在。

@thefourtheye 良好的性能解决方案，虽然我同意@naomik，但您不应该修改本机对象。说它应该在那里是题外话，问题是你正在修改 globals，这很糟糕。如果您将代码提供给其他人使用，那么它应该没有不可预见的副作用。想象一下，如果另一个库也修改了 Array.prototype，并且它做了一些稍微不同的事情，那么整个代码 [].clear() 都有些错误。调试起来不会很有趣。所以，一般信息是：不要修改全局变量。

@thefourtheye 不修改全局范围的全部意义在于，您不会知道其他人的代码是否已经（或将要）使用该名称。我建议在本地范围内使用一个函数。因此，在您的应用程序/库的 IIFE 中，执行 function clear(arr) { while(arr.length) arr.pop(); }，然后使用 clear(arr) 而不是 arr.clear() 清除数组。

事实证明，这种方法比 .splice() 和 .length=0 慢很多。基准不正确。请参阅我的更新答案。

答4:

与HuntsBot一起，探索全球自由职业机会–huntsbot.com

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

A.splice(0, A.length);

为什么这对跨浏览器更友好？哪些浏览器对 A.length 有问题？

@jm2 你所说的并不完全正确。它实际上修改了有问题的数组，随后所有引用都会受到影响。在我的 jsFiddle 上查看测试：jsfiddle.net/shamasis/dG4PH

@alex 不，它没有，splice 修改数组并返回已删除的条目。首先阅读文档：developer.mozilla.org/en-US/docs/JavaScript/Reference/…

我们可以通过使用 comma operator: A.splice(0, A.length),0; 来防止返回结果数组。这将留下 0 的返回值，就像 A.length = 0; 一样。结果数组仍然被创建，应该导致脚本运行速度变慢：（jsperf ~56% 慢）。浏览器实现会影响这一点，尽管我看不出为什么 splice 会比设置 length 更快。

我还发现只有 A.splice(0) 也可以。

答5:

huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

现在有不少于 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 数组内容的代码。

您建议的解决方案的唯一问题是垃圾仍然存在，只是您更改了布告栏说没有垃圾。对旧数组的引用应该仍然存在。你能确定垃圾收集器在设置 .length = 0 时也会删除对数组及其属性的所有引用吗？我认为它确实如此，但对我来说这很神奇。至少可以使用 .clear() 方法来避免混淆。

我从来没有说过这个解决方案是错误的。问题是这整个线程是完全不必要的。超过 3000 票表明，试图找出最好的方法应该使它成为 EMCA 破解头开发人员添加这种方法的足够有效的案例。没有人应该去弄清楚它。有三 - 四种不同的方法来做到这一点。在某些基准测试中，长度解决方案比其他解决方案慢得多。此外，对于任何合理的开发人员来说，设置 .length = 0 的想法都不会令人满意。

因为要完成它应该做的事情，必须删除所有引用。 .length = 0 甚至不是一个方法调用，所以如果在它设置为 0 时采取了其他操作（在大多数浏览器中通过定义 setter 进行），我仍然认为它太神奇了，无法真正相信它会做它应该做的事情去做。

因此，我宁愿自己清除它。一个清晰的方法可以被原型化，但这很丑陋。我的观点是，这个实现应该已经存在，因此超过 10 000 名开发人员不必花费数小时阅读这个线程，而不是考虑所有其他花费更多时间进行基准测试的人。

我喜欢这个答案中与现实世界的隐喻。感人的！

答6:

huntsbot.com洞察每一个产品背后的需求与收益，从而捕获灵感

性能测试：

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

在不注意您的平台的情况下添加百分比变化并没有多大用处。在我的机器上，pop 在 Chrome 34 中只是稍微快一点，但实际上比最新 Firefox 中的 [] 慢。

在 Firefox 39.0 32 位 Windows NT 6.3 64 位上测试，a=[] 是最快的！

这个 Chrome 下的测试结果肯定有问题。弹出循环怎么能比其他 3 个解决方案快得多？

@chqrlie 不是。这是最慢的方法。基准测试有缺陷。

请删除此答案，因为它是错误的，并链接到一个毫无意义的有缺陷的测试作为假证据。

答7:

huntsbot.com汇聚了国内外优秀的初创产品创意，可按收入、分类等筛选，希望这些产品与实践经验能给您带来灵感。

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

@naomik 你能解释一下你为什么不赞成这样做吗？

修改 Array 和 String 等 javascript 原始函数是“不受欢迎的”。您可能正在重载已经存在的函数并丢弃对象类。可能有一个晦涩的 JavaScript 引擎，它已经具有 clear() 并期望它以不同的方式运行。我只说小心行事。

对数组成员执行 foreach 会突然开始包含 clear 键的问题怎么样？

作为参考：Why is extending native objects a bad practice?

答8:

与HuntsBot一起，探索全球自由职业机会–huntsbot.com

您可以轻松地为您创建一个函数，更改 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(); //[]

arr.length = 0; //改变长度

答9:

huntsbot.com – 程序员副业首选，一站式外包任务、远程工作、创意产品分享订阅平台。

关于 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 是清除数组的最快方法（不考虑 []，因为虽然它是最快的，但实际上并没有清除现有数组）。

很好的一点！我将使用正确的基准测试结果更新原始答案。

我不敢相信没有人发现该基准错误。拥有超过 50 万次观看，您会期望有人注意到它。伟大的工作迪亚蒂斯

答10:

huntsbot.com精选全球7大洲远程工作机会，涵盖各领域，帮助想要远程工作的数字游民们能更精准、更高效的找到对方。

如果您正在使用

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

除了在 a.length 上出错之外，我没有看到这个新答案在线程中添加了什么？

@Bergi我只想关注关于数组的实际内存表示

您是否有任何消息来源可以确认在执行 a.length=0; 时哪些 JS 引擎将创建一个新数组？这些引擎将如何作用于 a.length=500; 和 a.length=4;？

我在大多数浏览器上都试过了，比如 IE、Firefox、Chrome，它正在创建新数组。如果将长度设置为大于 0，那么它将创建一个包含未定义元素的数组，即它只会保存一些内存位置。

var a = [1]; var b = a; a.length = 0; console.log(b) 打印 Array [ ]，所以它看起来不像是在创建一个新数组。

答11:

打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

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

并称之为：array.clear();

请不要鼓励修改原生对象。

为什么人们有这种倾向去获取已接受的答案并将其放入原型函数中？你真的在你的项目中这样做吗？您是否有一个庞大的原型库，包含在每个项目中？

为什么不直接输入 array.length = 0？

@naomik “请不要鼓励修改原生对象。” ——我完全同意这一点，但仅仅重复这句话本身就会显得傲慢。提出这样一个解决方案的人可能没有意识到后果，并且在他们身上放下这一行而不是提供简短的解释或链接并没有传达除“我们，比你聪明的人，告诉你不要这样做，因为我们更了解”。

作为参考：Why is extending native objects a bad practice?

原文链接：https://www.huntsbot.com/qa/rDZ6/how-do-i-empty-an-array-in-javascript?lang=zh_CN&from=csdn

一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会