current community

your communities

more stack exchange communities

company blog
Stack Exchange Inbox Reputation and Badges
tour help
stack overflow careers
Sign up ×
Stack Overflow is a community of 4.7 million programmers, just like you, helping each other. Join them, it only takes a minute:
up vote 1223 down vote favorite
281

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?

share|improve this question
8  
Kudos to Phillipe Leybaert for updating his answer in response (see his updated answer below). – simon Jul 1 '14 at 18:59

16 Answers 16

up vote 1380 down vote accepted

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.

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 .splice() function will return an array with all the removed items, it will actually return a copy of the original array. Benchmarks suggests 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.

EDIT

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 2nd iteration was clearing an array that was already empty.

The following benchmark fixes this flaw: http://jsperf.com/array-destroy/151 . 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).

share|improve this answer
66  
while (A.length) { A.pop(); }, no need for > 0 – Ivan Black Aug 8 '14 at 12:41
100  
> 0 is more readable IMHO. And there's no performance difference between the two. – Philippe Leybaert Aug 8 '14 at 19:46
4  
@daghan Your point? – Philippe Leybaert Aug 15 '14 at 4:04
5  
@DiegoJancic Method #1 doesn't count because it doesn't clear the array. It creates a new one. It shouldn't be included in a benchmark. – Philippe Leybaert Nov 7 '14 at 14:15
11  
You can't use while(A.pop()) in case an item in the array is falsey. Take for example A = [2, 1, 0, -1, -2] would result in A equaling [2, 1]. Even while(A.pop() !== undefined) doesn't work because you can have an array with undefined as one of the values. Probably why the compiler doesn't optimized it. – Jonathan Gawrych Jan 9 at 1:29
up vote 1775 down 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;
share|improve this answer
8  
@Acorn Yes, it will work in all browsers. – Matthew Crumley May 10 '11 at 22:01
10  
what does ECMAScript 5 Standard says about this? – Pacerier Jun 21 '11 at 7:00
144  
@Pacerier: It still works in ES5. From section 15.4: "...whenever the length property is changed, every property whose name is an array index whose value is not smaller than the new length is automatically deleted" – Matthew Crumley Jun 21 '11 at 7:43
6  
@LosManos Even in strict mode, length is a special property, but not read only, so it will still work. – Matthew Crumley Jan 4 '13 at 14:18
9  
@MattewCrumley I done some test, and it seems like a.length = 0 is not to efficient clearing whole array. jsperf.com/length-equal-0-or-new-array I think if you have one refence (and you haven't added extra properties that you want to keep), it is better to create new array, and leaves old to the garbage collector, that will run when appropriate. – Paul Brewczynski Nov 16 '13 at 19:08
up vote 160 down vote

Here the fastest working implementation while keeping the same array:

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

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

And the tests that goes with it:

describe('Array', function() {
  it('should clear the array', function() {
    var 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

share|improve this answer
5  
TT your answer is the only one that correct and fast ( at the same time ) but have some much less "upvotes". Well, it seems that people like pretty solutions that are slow :/ – Ai_boy Jun 26 '13 at 5:09
5  
@thefourtheye Good solution for performance, though I agree with @naomik, you should not modify native objects. Saying that it should be there is beside the point, the problem is you're modifying globals, which is bad. If you're providing your code for others to use, then it should have no unforeseen side effects. Imagine if another library also modified the Array.prototype and it was doing something slightly different, then all throughout your code [].clear() was slightly wrong. This would not be fun to debug. So, the general message is: Don't modify globals. – jpillora Sep 14 '13 at 10:39
2  
@thefourtheye The whole point of not modifying global scope is because you won't know if someone else's code is already (or will be) using the name. I suggest a function inside local scope. So, inside your application's/library's IIFE, do function clear(arr) { while(arr.length) arr.pop(); }, then clear arrays with clear(arr) instead of arr.clear(). – jpillora Sep 15 '13 at 4:58
1  
I like the noise this one makes while its working. – simon Jul 1 '14 at 19:11
1  
It turns out this method is a lot slower than .splice() and .length=0. The benchmarks were not correct. See my updated answer. – Philippe Leybaert Feb 17 at 1:30
up vote 79 down 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);

share|improve this answer
29  
Why is this more cross-browser friendly? What browsers have issues with A.length? – stricjux Nov 21 '11 at 15:12
3  
@jm2 what you are saying is not entirely true. It actually modifies the array in question and subsequently all references get affected. See the test on my jsFiddle: jsfiddle.net/shamasis/dG4PH – Shamasis Bhattacharya Sep 26 '12 at 12:38
3  
@alex no it does not, splice modifies the array and returns the deleted entries. Read the docs first: developer.mozilla.org/en-US/docs/JavaScript/Reference/… – David Oct 29 '12 at 16:22
3  
We could prevent the resulting array from being returned by using the comma operator: A.splice(0, A.length),0;. This would leave a return value of 0 just as A.length = 0; would. The resulting array is still created and should cause the script to run slower: (jsperf ~56% slower). Browser implementation will affect this although I see no reason why splice would be faster than setting length. – Evan Kennedy Aug 18 '13 at 3:47
2  
splice is also incredibly slow as compared to other methods jsperf.com/array-splice-vs-array-length-0/2 – kumar_harsh Jan 10 '14 at 13:55
up vote 24 down vote

You can add this to your JavaScript file to allow your arrays to be "cleared":

Array.prototype.clear = function() {
    this.splice(0, this.length);
};

Then you can use it like this:

var list = [1, 2, 3];
list.clear();

Or if you want to be sure you don't destroy something:

if (!Array.prototype.clear) {
    Array.prototype.clear = function() {
       this.splice(0, this.length);
    };
}

Lots of people think you shouldn't modify native objects (like Array), and I'm inclined to agree. Please use caution in deciding how to handle this.

share|improve this answer
1  
@naomik Can you explain your reasoning why doing such a thing is frowned upon? – Undefined Sep 16 '13 at 16:24
3  
It is "frowned upon" to modify javascript primitive functions like Array and String. You could possibly be overloading an already existing function and trash the object class. There might be an obscure javascript engine that already has clear() and expects it to behave a different way. Tread carefully is all I say. – Design by Adrian Mar 25 '14 at 15:20
    
How about the problem where doing a foreach over the members of an array will suddenly start including a clear key? – ErikE Aug 14 at 0:00
up vote 15 down vote

performance test

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
share|improve this answer
2  
Adding the percentage changes arent much use without also noting your platform. On my machine pop is only very mildly quicker in Chrome 34 but actually slower than [] in latest Firefox. – Matt Styles May 15 '14 at 10:56
    
Testing in Firefox 39.0 32-bit on Windows NT 6.3 64-bit, the a=[] is fastest ! – Reza-S4 Apr 15 at 8:59
    
of course that creating a new instance of the array is faster than looping and popping it... so if popping is faster in chrome means the creation of a new array creation is buggy – HellBaby Apr 27 at 10:58
up vote 15 down vote 
Array.prototype.clear = function() {
    this.length = 0;
};

and call it: array.clear();

=)

share|improve this answer
35  
Please don't encourage modification of the native objects. – naomik Jul 7 '13 at 6:53
9  
why do people have this tendency to grab the accepted answer and put it into a prototype function? Do you actually do this in your projects? Do you have a huge library of prototype additions that you include in every project? – nurettin Nov 29 '13 at 11:05
4  
Why not just type array.length = 0? – Design by Adrian Mar 25 '14 at 15:24
1  
PLEASE hackers / developers .... don`t mod things, where would that get us . – James Andino Jul 8 '14 at 17:53
    
How could this get any upvote? No browser I know allows this = ... EDIT: I see, answer was different in previous versions. – Chips_100 Dec 22 '14 at 13:50
up vote 7 down vote

In case you are interested in the memory allocation, you may compare each approach using something like this jsfiddle in conjunction with chrome dev tools' timeline tab. You will want to use the trash bin icon at the bottom to force a garbage collection after 'clearing' the array. This should give you a more definite answer for the browser of your choice. A lot of answers here are old and I wouldn't rely on them but rather test as in @tanguy_k's answer above.

(for an intro to the aforementioned tab you can check out here)

Stackoverflow forces me to copy the jsfiddle so here it is:

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

And you should take note that it may depend on the type of the array elements, as javascript manages strings differently than other primitive types, not to mention arrays of objects. The type may affect what happens.

share|improve this answer
up vote 6 down vote

How about the below modified version of Jan's initial suggestion?

var originalLength = A.length;
for(var i = originalLength; i > 0; i--) {
     A.pop();
}
share|improve this answer
5  
Why would you want to do such thing? Why add two more variables and a bunch of code to do the same thing? – Killah Sep 14 '14 at 22:51
up vote 5 down vote

There is a lot of confusion and misinformation regarding the while;pop/shift performance both in answers and comments. The while/pop solution has (as expected) the worst performance. What's actually happening is that setup runs only once for each sample that runs the snippet in a loop. eg:

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

I have created a new test that works correctly :

http://jsperf.com/empty-javascript-array-redux

Warning: even in this version of the test you can't actually see the real difference because cloning the array takes up most of the test time. It still shows that splice is the fastest way to clear the array (not taking [] into consideration because while it is the fastest it's not actually clearing the existing array).

share|improve this answer
    
Very good point! I'll update the original answer with the correct benchmark results. – Philippe Leybaert Feb 16 at 23:50
    
I can't believe nobody spotted that benchmark error. With over half a million views you would expect someone to notice it. Great work Diadistis – Philippe Leybaert Feb 17 at 0:15
    
I've updated my answer – Philippe Leybaert Feb 17 at 0:31
up vote 5 down vote

If you are using 

a = [];

or

a.length = 0;

then you are just creating new array which points to specific memory location. This means previous array will be remain in memory till garbage collection. So its not the better way to use. Instead of these two solutions are better.

a.splice(0,a.length)

and

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

As per previous answer by kenshou.html, second method is faster.

share|improve this answer
2  
Apart from being wrong on a.length, I don't see what this new answer adds to the thread? – Bergi Dec 1 '14 at 14:33
    
@Bergi I just want to focus about actual memory representation about array – Laxmikant Dange Dec 2 '14 at 9:30
    
Do you have any source to confirm which JS engines will create a new array when a.length=0; is performed? How would those engines act for a.length=500; and a.length=4;? – joeytwiddle Dec 13 '14 at 18:38
    
I tried it on most of browsers, like IE, Firefox, Chrome, it is creating new array. If you set length greater than 0 then it will create an array with undefined elements, i.e. it will just hold some memory locations. – Laxmikant Dange Dec 16 '14 at 15:21
up vote 2 down vote

A.splice(0);

I just did this on some code I am working on. It cleared the array.

share|improve this answer
up vote 0 down vote

behavior comparison between arr = [] vs arr.pop() loop:

var arr = [1,2,3];
var arrCopy = arr;
arr = [];
console.log(arrCopy.length); /* outputs 3: arr points to a NEW array (which is empty), arrCopy still points to [1,2,3] */

var brr = [4,5,6,7];
var brrCopy = brr;
while(brr.length){
    brr.pop();
}
console.log(brrCopy.length); /* outputs 0: brr and brrCopy points to the same array, whose elements are removed in the loop */
share|improve this answer
up vote -3 down vote

Simply re initialize it. No need to delete even.

A = [];
share|improve this answer
7  
There is no point deleting it if you are re-referencing it. – Design by Adrian Mar 25 '14 at 15:25
up vote -4 down vote

There are different ways to clear array depending on requirement. The results below are for chrome.

  1. array = []; //Fastest
  2. while(array.length > 0) { array.pop(); } //Faster
  3. a.splice(0,a.length) //Slowest
  4. a.length = 0; //Slowest

array = []; does not clear original array shared among other references, it only creates new instance. a.splice(0,a.length); clears memory also.

share|improve this answer
up vote -6 down vote

The fastest solution for all current browsers is to implement the pop or shift method. Combining answers from leech and Jan, we can come up with a method that is declared once and makes it easy to clear the array:

Array.prototype.clear = function()  //Add a new method to the Array Object
{
    var ii = this.length;
    for(var i=0;i<ii;i++)
    {
        this.pop();
    }
}

var NumberList = new Array();  //Declare the variable
NumberList.push(111);          //Add number to the end of the list
NumberList.clear;              //Clear the list

Or you could just use a while loop:

while(your_array_name_here.length > 0)
    your_array_name_here.pop();

But the best answer as found above would be to use the length property straight up.

your_array_name_here.length = 0;
share|improve this answer
2  
This answer is wrong since Jan implementation is, as 755 said: "only pops half of the elements in the array, since this.length is decreasing as i is increasing" and I've verified this myself – tanguy_k Jun 25 '13 at 20:09
7  
Please don't encourage modification of the native objects. – naomik Jul 7 '13 at 6:54

protected by Praveen Kumar Jul 8 '14 at 18:19

Thank you for your interest in this question. Because it has attracted low-quality answers, posting an answer now requires 10 reputation on this site.

Would you like to answer one of these unanswered questions instead?

Not the answer you're looking for? Browse other questions tagged or ask your own question.