有没有方法清空数组，如果有可能，可以使用.remove（）？
例如，
A = [1,2,3,4];
我怎么才能把它清空？
清除现有阵列A的方法：
方法1
（这是我对问题的最初回答）
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来清除现有数组。当在ECMAScript 5中使用“严格模式”时，它也可以工作，因为数组的长度属性是读/写属性。
方法3（安东尼建议）
A.splice(0,A.length)
使用.splice（）可以很好地工作，但由于.splice（）函数将返回一个包含所有移除项的数组，因此它实际上将返回原始数组的副本。基准表明，这对绩效没有任何影响。
方法4（由tanguy_k建议）
while(A.length > 0) {
A.pop();
}
这个解决方案不是很简洁，也是最慢的解决方案，与原始答案中引用的早期基准相反。
表演
在清除现有数组的所有方法中，方法2和3的性能非常相似，比方法4快得多。请参阅此基准。
正如Diadistis在下面的回答中指出的，用于确定上述四种方法性能的原始基准存在缺陷。原始基准测试重用了已清除的数组，因此第二次迭代正在清除已为空的数组。
以下基准测试修复了此缺陷：http://jsben.ch/#/hyj65.它清楚地表明，方法#2（长度属性）和#3（拼接）是最快的（不包括方法#1，它不会改变原始数组）。
这一直是一个热门话题，引起了很多争议。实际上有很多正确的答案，因为这个答案已经被标记为公认答案很长一段时间了，我将在这里包括所有的方法。
您可以将其添加到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），我倾向于同意。在决定如何处理这件事时请谨慎。
这里是保持相同数组（“可变”）的最快工作实现：
function clearArray(array) {
while (array.length > 0) {
array.pop();
}
}
仅供参考，它不能简化为while（array.pop（））：测试将失败。
仅供参考，Map和Set定义clear（），Array也可以使用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/32 http://jsperf.com/array-destroy/152
jsPerf脱机。类似基准：https://jsben.ch/hyj65
使用Jan最初建议的修改版本：
var originalLength = A.length;
for (var i = originalLength; i > 0; i--) {
A.pop();
}
Terser公司：
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*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管理字符串的方式不同于其他基本类型，更不用说对象数组了。类型可能会影响发生的情况。
性能测试：
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
如果您正在使用
a = [];
然后将新的数组引用分配给，如果中的引用已经分配给任何其他变量，那么它也不会清空该数组，因此垃圾收集器不会收集该内存。
例如。
var a=[1,2,3];
var b=a;
a=[];
console.log(b);// It will print [1,2,3];
or
a.length = 0;
当我们指定a.length时，我们只是重置数组和内存的边界，其余数组元素将由垃圾收集器连接。
而不是这两种解决方案更好。
a.splice(0,a.length)
and
while(a.length > 0) {
a.pop();
}
根据kenshou.html先前的回答，第二种方法更快。
关于这段时间，有很多困惑和错误信息；回答和评论中的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
警告：即使在这个版本的测试中，您也看不到真正的差异，因为克隆阵列占用了大部分测试时间。它仍然表明拼接是清除阵列的最快方式（不考虑[]，因为虽然它是最快的，但实际上并没有清除现有阵列）。
到目前为止，支持票不少于2739票的答案是误导和错误的。
问题是：“如何清空现有阵列？”例如，对于A=[1,2,3,4]。
说“A=[]是答案”是无知的，绝对不正确。[]==[]为假。这是因为这两个阵列是两个独立的对象，具有各自的两种身份，在数字世界中占据各自的空间，各自独立。
假设你妈妈让你清空垃圾桶。
你不会把一个新的带进来，就好像你已经完成了被要求的事情。相反，你倒垃圾桶。你不会用新的空罐替换已填充的罐，也不会从已填充的罐子中取出标签“a”并将其粘贴到新的罐上，如a=[1,2,3,4]；A=[]；
清空数组对象是有史以来最简单的事情：
A.length = 0;
这样，“A”下的罐子不仅是空的，而且干净如新！
此外，在垃圾桶清空之前，您不需要手动清除垃圾！你被要求一次彻底清空现有的垃圾桶，直到垃圾桶变空后再去捡垃圾，如下所示：而（A长度>0）{A.pop（）；}也不要把你的左手放在垃圾桶的底部，右手放在顶部，这样就可以把垃圾桶里的东西拿出来，如下所示：A.拼接（0，A.长度）；
不，你被要求清空它：
A.length = 0;
这是唯一正确清空给定JavaScript数组内容的代码。
要清空数组的当前内存位置，请使用：“myArray.length=0”或“myArray.cop（）UN，直到其长度为0”
length：可以将length属性设置为随时截断数组。通过更改数组的长度属性来扩展数组时，实际元素的数量会增加。pop（）：pop方法从数组中移除最后一个元素，并返回移除的值。shift（）：shift方法移除第0个索引处的元素，并向下移动连续索引处的值，然后返回移除的值。
例子：
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构造函数或数组文字创建具有新内存位置的Array。mainArr=[]；//新的空数组被寻址到mainArr。var arr=新数组（“10”）；//数组构造函数arr.unshift（'1'）；//添加到前面arr.push（'15'）；//添加到末尾console.log（“添加后：”，arr）；//["1", "10", "15"]arr.pop（）；//从末端移除arr.shift（）；//从前面拆下console.log（“删除后：”，arr）；//["10"]var arrLit=['14'，'17']；console.log（“array literal«”，indexedItem（arrLit））；//{0,14}{1,17}函数索引项{var indexedStr=“”；arr.forEach（函数（项、索引、数组）{indexedStr+=“｛”+index+“，”+item+“｝”；console.log（项，索引）；});返回indexedStr；}slice（）：通过使用slice函数，我们从原始数组中获得一个元素的浅拷贝，带有新的内存地址，这样对clonerr的任何修改都不会影响到实际的|原始数组。var浅拷贝=mainArr.slice（）；//这是如何复制的var cloneArr=mainArr.切片（0，3）；console.log（'Main'，mainArr，'\tCloned'，cloneArr）；克隆错误长度=0；//清除阵列的当前内存位置。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）生成等效的数组
您可以轻松地创建一个函数来实现这一点，更改长度，甚至将其作为remove（）函数添加到本机Array中以供重用。
假设您有此阵列：
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(); //[]
推荐文章
- 检测用户何时离开网页的最佳方法?
- 当“模糊”事件发生时，我如何才能找到哪个元素的焦点去了*到*?
- React不会加载本地图像
- 如何将Blob转换为JavaScript文件
- 在另一个js文件中调用JavaScript函数
- 如何在svg元素中使用z索引?
- 数组添加 vs +=
- 如何求一个数的长度?
- 跨源请求头(CORS)与PHP头
- 如何用Express/Node以编程方式发送404响应?
- parseInt(null, 24) === 23…等等,什么?
- JavaScript变量声明在循环外还是循环内?
- 元素在“for(…in…)”循环中排序
- 在哪里放置JavaScript在HTML文件?
- 什么时候.then(success, fail)被认为是承诺的反模式?
