How do I empty an array in JavaScript?

 

Is there a way to empty an array and if so possibly with .remove() ?

For instance, 

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

How can I empty that?

Ways to clear an existing array A :

Method 1

(this was my original answer to the question) 

A = [];

This code will set the variable A to a new empty array. This is perfect if you don't have references to the original array A anywhere else because this actually creates a brand new (empty) array. You should be careful with this method because if you have referenced this array from another variable or property, the original array will remain unchanged. Only use this if you only reference the array by its original variable A .

This is also the fastest solution.

This code sample shows the issue you can encounter when using this method: 

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']

Method 2 (as suggested by Matthew Crumley) 

A.length = 0

This will clear the existing array by setting its length to 0. Some have argued that this may not work in all implementations of JavaScript, but it turns out that this is not the case. It also works when using "strict mode" in ECMAScript 5 because the length property of an array is a read/write property.

Method 3 (as suggested by Anthony) 

A.splice(0,A.length)

Using .splice() will work perfectly, but since the .splice() function will return an array with all the removed items, it will actually return a copy of the original array. Benchmarks suggest that this has no effect on performance whatsoever.

Method 4 (as suggested by tanguy_k) 

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

This solution is not very succinct, and it is also the slowest solution, contrary to earlier benchmarks referenced in the original answer.

Performance

Of all the methods of clearing an existing array , methods 2 and 3 are very similar in performance and are a lot faster than method 4. See this benchmark.

As pointed out by Diadistis in their answer below, the original benchmarks that were used to determine the performance of the four methods described above were flawed. The original benchmark reused the cleared array so the second iteration was clearing an array that was already empty.

The following benchmark fixes this flaw: http://jsben.ch/#/hyj65. It clearly shows that methods #2 (length property) and #3 (splice) are the fastest (not counting method #1 which doesn't change the original array).

This has been a hot topic and the cause of a lot of controversy. There are actually many correct answers and because this answer has been marked as the accepted answer for a very long time, I will include all of the methods here. If you vote for this answer, please upvote the other answers that I have referenced as well.

如果您需要保留原始数组，因为您还需要更新其他引用，那么可以通过将其长度设置为零来清除它，而无需创建新数组： 

A.length = 0;

Here the fastest working implementation while keeping the same array ("mutable"): 

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

FYI Map defines clear() so it would seem logical to have clear() for Array too.

Or as an Underscore.js mixin: 

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

Or a simple function: 

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

TypeScript version: 

function clearArray<T>(array: T[]) {
  while (array.length) {
    array.pop();
  }
}

FYI it cannot be simplified to while (array.pop()) : the tests will fail.

And the tests that goes with it: 

describe('Array', () => {
  it('should clear the array', () => {
    let array = [1, 2, 3, 4, 5];
    array.clear();
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);

    // Even with undefined or null inside
    array = [1, undefined, 3, null, 5];
    array.clear();
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);
  });
});

Here the updated jsPerf: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

链接地址: http://www.djcxy.com/p/598.html

上一篇: 如何有效地迭代'Map'中的每个条目？

下一篇: 如何在JavaScript中清空数组？