如何在JavaScript中清空数组?

2020/09/15 01:31 · javascript ·  · 0评论

有没有一种方法可以清空数组.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']

方法2Matthew Crumley 建议

A.length = 0

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

方法3Anthony 建议

A.splice(0,A.length)

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

方法4tanguy_k 建议

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

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

性能

在清除现有阵列的所有方法中,方法2和3在性能上非常相似,并且比方法4快得多请参阅此基准测试

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

以下基准测试解决了该缺陷:http : //jsben.ch/#/hyj65它清楚地显示了方法#2(长度属性)和#3(拼接)是最快的(不计算不会改变原始数组的方法#1)。


这一直是一个热门话题,并且引起了很多争议。实际上有许多正确答案,并且由于很长一段时间以来该答案都已被标记为可接受答案,因此,我将在此处介绍所有方法。如果您对此答案投了赞成票,请同时投票赞成我引用的其他答案。

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

A.length = 0;

这里最快的落实工作,同时保持相同的阵列(“可变”):

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

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

FYI MapSet 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

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

A.splice(0, A.length);

到目前为止,至少有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. 也不要将左手放在垃圾箱的底部,而将右手放在垃圾箱的顶部,这样就可以拉出其内容:

    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),我倾向于同意。请谨慎决定如何处理。

关于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是清除阵列的最快方法(没有[]考虑,因为虽然这是最快的,但实际上并未清除现有阵列)。

您可以轻松地创建一个函数来为您执行此操作,更改长度,甚至将其添加到本机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(); //[]

如果您对内存分配感兴趣,可以使用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.prototype.clear = function() {
    this.length = 0;
};

并称之为: array.clear();

如果您正在使用

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.splice(0);

我只是在我正在处理的某些代码上执行过此操作。它清除了阵列。

使用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);

我很惊讶还没有人建议这样做:

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);
    }
}
本文地址:http://javascript.askforanswer.com/ruhezaijavascriptzhongqingkongshuzu.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!