How do I empty an array in JavaScript?

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;

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

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

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

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.

This is interesting. The answers that took no less that 1808 up-votes by now are misleading and incorrect.

The question is "how do you empty your existing Array object"? E.g.: A = [1,2,3,4];

1. Saying: A = []; is the answer. Is ignorant, as is absolutely incorrect.

   [ ] == [ ] // is false.

Because they are two separate; individual objects, with their own two identities taking their own physical space of their 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!

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

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

3. 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 equivalent syntax of the correct sense of "emptying" / "throwing away" the content of the given JavaScript Array Object.

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

and call it: array.clear();

=)

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.

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

Use a modified version of Jan's initial suggestion:

var originalLength = A.length;
for (var i = originalLength; i > 0; i--) {
     A.pop();
}

Simply to empty array

var  A = [1,2,3,4];   // array value 

A.length = 0 ;   // create empty array 

or

A = [];

A.splice(0);

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

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.

To Empty a Current memory location of an array use: 'myArray.length = 0' or 'myArray.pop() UN-till its length is 0'

• length : Pops till length of an array is of Specified Size.
• pop() : The pop method removes the last element from a current memory address of an array.

Example:

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

Use slice() : when you want to clone an array from given array with new memory address, So that any modification on cloneArr will not affect to an actual array.

Empty Array with new Memory address use : slice(0, 0)

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

To assigning new empty array [] with a new memory location.

mainArr = []; // a new empty array is addressed to mainArr.

var arr = [1,2,3,5];

You can use:

1. arr.length = 0;
2. arr.splice(0);
3. arr = arr.constructor();
4. arr = [];

Behavior comparison between arr = [] vs a 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), and 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. */

By using loop process to empty an array in java script.

<script>
var name= ["Aalam", "Geer", "Rana", "India"];

function myFunction() {
    name.pop();
}
for($a=name.length;$a>=0; $a-- ){
   myFunction();
}
</script>