How do I empty an array in JavaScript?

ID : 376

viewed : 159

Tags : javascriptarraysjavascript

Top 5 Answer for How do I empty an array in JavaScript?

vote vote


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)


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.


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: 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.

vote vote


If you need to keep the original array because you have other references to it that should be updated too, you can clear it without creating a new array by setting its length to zero:

A.length = 0; 
vote vote


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

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

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

FYI Map and Set define clear(), it would have seem logical to have clear() for Array too.

TypeScript version:

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

The corresponding tests:

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);   }); }); 

Here the updated jsPerf:

jsPerf offline. Similar benchmark:

vote vote


A more cross-browser friendly and more optimal solution will be to use the splice method to empty the content of the array A as below:

A.splice(0, A.length);

vote vote


The answers that have no less that 2739 upvotes by now are misleading and incorrect.

The question is: "How do you empty your existing array?" E.g. for A = [1,2,3,4].

  1. Saying "A = [] is the answer" is ignorant and absolutely incorrect. [] == [] is false.

    This is because these two arrays are two separate, individual objects, with their own two identities, taking up their own space in the digital world, each on its own.

Let's say your mother asks you to empty the trash can.

  • You don't bring in a new one as if you've done what you've been asked for.
  • Instead, you empty the trash can.
  • You don't replace the filled one with a new empty can, and you don't take the label "A" from the filled can and stick it to the new one as in A = [1,2,3,4]; A = [];

Emptying an array object is the easiest thing ever:

A.length = 0; 

This way, the can under "A" is not only empty, but also as clean as new!

  1. Furthermore, you are not required to remove the trash by hand until the can is empty! You were asked to empty the existing one, completely, in one turn, not to pick up the trash until the can gets empty, as in:

    while(A.length > 0) {     A.pop(); } 
  2. Nor, to put your left hand at the bottom of the trash, holding it with your right at the top to be able to pull its content out as in:

    A.splice(0, A.length); 

No, you were asked to empty it:

A.length = 0; 

This is the only code that correctly empties the contents of a given JavaScript array.

Top 3 video Explaining How do I empty an array in JavaScript?