如何在JavaScript中清空数组？
Answers:
清除现有数组的方法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 建议）
A.length = 0这将通过将其长度设置为0来清除现有数组。有人认为这可能不适用于JavaScript的所有实现，但事实并非如此。当在ECMAScript 5中使用“严格模式”时，它也可以工作，因为数组的length属性是读/写属性。
A.splice(0,A.length)使用.splice()将完美地工作，但是由于该.splice()函数将返回一个包含所有已删除项目的数组，因此它实际上将返回原始数组的副本。基准表明，这对性能没有任何影响。
while(A.length > 0) {
A.pop();
}
与原始答案中引用的早期基准相反，此解决方案不是很简洁，它也是最慢的解决方案。
性能
在清除现有数组的所有方法中，方法2和3在性能上非常相似，并且比方法4快得多。请参阅此基准。
正如Diadistis在下面的回答中所指出的那样，用于确定上述四种方法的性能的原始基准存在缺陷。原始基准测试重复使用了已清除的数组，因此第二次迭代将清除已经为空的数组。
以下基准测试解决了此缺陷：http : //jsben.ch/#/hyj65。它清楚地显示了方法＃2（长度属性）和＃3（拼接）是最快的（不计算不会改变原始数组的方法＃1）。
这一直是一个热门话题，并且引起了很多争议。实际上，有很多正确答案，并且由于很长一段时间以来该答案都已被标记为可接受答案，因此我将在此处介绍所有方法。如果您对此答案投赞成票，请同时投票赞成我引用的其他答案。
while (A.length) { A.pop(); }，无需> 0
> 0更具可读性的恕我直言。两者之间没有性能差异。
b即使a分配了新数组，也保留对旧数组的引用。c并d继续引用相同的数组。因此，预计会有产出差异。
while(A.pop())数组中的项目为假，则不能使用。例如，A = [2，1，0，-1，-2]将导致A等于[2，1]。甚至while(A.pop() !== undefined)不起作用，因为您可以将未定义的数组作为值之一。可能是编译器未对其进行优化的原因。
如果您需要保留原始数组，因为还有其他对它的引用也应该更新，则可以通过将其长度设置为零来清除它而无需创建新数组：
A.length = 0;myarray.push(whatever)它时，它会增加一个长度。因此，设置长度会截断数组，但它不是永久的。
length也是一个特殊属性，但不是只读属性，因此它将仍然有效。
这里最快的落实工作，同时保持相同的阵列（“可变”）：
function clearArray(array) {
while (array.length) {
array.pop();
}
}
仅供参考，它不能简化为while (array.pop())：测试将失败。
FYI Map和Set define clear()，clear()对于Array也似乎是合乎逻辑的。
TypeScript版本：
function clearArray<T>(array: T[]) {
while (array.length) {
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
Array.prototype并且所做的事情略有不同，那么整个代码[].clear()中的所有内容都是错误的。调试起来不会很有趣。因此，一般的信息是：不要修改全局变量。
.splice()和慢很多.length=0。基准不正确。看到我更新的答案。
跨浏览器更友好，更优化的解决方案是使用该splice方法清空数组A的内容，如下所示：
A.splice(0, A.length);
splice修改数组并返回删除的条目。首先阅读文档：developer.mozilla.org/en-US/docs/JavaScript/Reference/...
A.splice(0)也行得通。
到目前为止，至少有2739票赞成的答案具有误导性和不正确性。
问题是：“如何清空现有阵列？” 例如A = [1,2,3,4]。
说“
A = []是答案”是无知的，而且绝对不正确。[] == []是错误的。这是因为这两个数组是两个单独的独立对象，具有各自的两个标识，它们在数字世界中占据了各自的空间，每个空间都是独立的。
假设您的母亲要您清空垃圾桶。
- 您不会带来新的功能，就好像您已经完成了要求的操作一样。
- 相反，您清空垃圾箱。
- 您不要用新的空罐替换装满的罐，也不要从装满的罐上取标签“ A”并将其粘贴到新的罐上。
A = [1,2,3,4]; A = [];
清空数组对象是最简单的事情：
A.length = 0;这样，“ A”下的罐不仅是空的，而且像新的一样干净！
此外，在罐头变空之前，无需手动清除垃圾！您被要求完全倒空现有的一个，直到罐头变空之前不要捡垃圾，如下所示：
while(A.length > 0) { A.pop(); }也不要将左手放在垃圾箱的底部，而将右手放在垃圾箱的顶部，以便像下面那样拉出其内容：
A.splice(0, A.length);
不，您被要求清空它：
A.length = 0;这是唯一可以正确清空给定JavaScript数组内容的代码。
A(n) = A.splice( 0, A.length );您需要备份以前的内容。ps Array.length是一个读写属性\方法，以防您错过了这个基本事实。意思是，您可以将其扩展为新的长度，不能将其修剪为所需的任何长度，除其他外，还可以通过将其长度缩短为0来丢弃所有成员。这是数组的瑞士刀。
性能测试：
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），我倾向于同意。在决定如何处理时，请谨慎使用。
clear键的问题怎么样？
关于while的信息存在很多困惑和错误信息；在答案和评论中都出现流行/移位表现。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是清除阵列的最快方法（没有[]考虑，因为虽然这是最快的，但实际上并未清除现有阵列）。
如果您对内存分配感兴趣，可以使用jsfiddle之类的东西与chrome dev工具的“时间轴”标签相比较，比较每种方法。您将需要使用底部的垃圾桶图标“清除”阵列后强制进行垃圾收集。这应该为您选择的浏览器提供更明确的答案。这里有很多答案很老，我不会依赖它们，而是像上面@tanguy_k的答案一样进行测试。
（有关上述标签的介绍，您可以在此处查看）
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与其他基本类型不同，其管理字符串的方式更不用说对象数组了。类型可能会影响发生的情况。
您可以轻松创建一个函数来为您执行此操作，更改长度，甚至将其添加到本机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(); //[]Array.prototype.clear = function() {
this.length = 0;
};并称之为： array.clear();
A.splice(0);
我只是在我正在处理的某些代码上执行过此操作。它清除了数组。
如果您正在使用
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，我看不到这个新答案为线程增加了什么？
a.length=0;？这些引擎将如何行事a.length=500;和a.length=4;？
var a = [1]; var b = a; a.length = 0; console.log(b)prints Array [ ]，所以似乎并没有为我创建一个新数组。
使用Jan最初建议的修改版本：
var originalLength = A.length;
for (var i = originalLength; i > 0; i--) {
A.pop();
}如果使用常量，则别无选择：
const numbers = [1, 2, 3]您不能重新分配：
numbers = []您只能截断：
numbers.length = 0
要清空阵列的当前内存位置，请使用：'myArray.length = 0'或'myArray.pop() UN-till its length is 0'
length：您可以设置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());
}
};new Array() | []使用Array constructor或创建具有新内存位置的数组array literal。mainArr = []; // a new empty array is addressed to mainArr. var arr = new Array('10'); // Array constructor arr.unshift('1'); // add to the front arr.push('15'); // add to the end console.log("After Adding : ", arr); // ["1", "10", "15"] arr.pop(); // remove from the end arr.shift(); // remove from the front console.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()：通过使用slice函数，我们从原始数组中获得了具有新存储器地址的浅表元素副本，从而对cloneArr进行的任何修改都不会影响实际数组。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);
length = ?而不是仅仅说length。
我很惊讶还没有人建议这样做：
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);
}
}