How do I empty an array in JavaScript?

Answer 1

Use a modified version of Jan's initial suggestion:

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

Terser:

for (let i = A.length; i > 0;A.pop(),i--) {}

Or here's another take:

while(!A[Symbol.iterator]().next().done)A.shift()

Answer 2

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!

---

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

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 code that correctly empties the contents of a given JavaScript array.

Answer 3

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

Answer 4

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

• length : You can set the length property to truncate an array at any time. When you extend an array by changing its length property, the number of actual elements increases.
• pop() : The pop method removes the last element from an array and returns that returns the removed value.
• shift() : The shift method removes the element at the zeroeth index and shifts the values at consecutive indexes down, then returns the removed value.

Example:

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() | [] Create an Array with new memory location by using Array constructor or 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() : By using slice function we get an shallow copy of elements from the original array, with new memory address, So that any modification on cloneArr will not affect to an actual|original array.

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

Answer 5

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: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

Answer 6

If you use constants then you have no choice:

const numbers = [1, 2, 3]

You can not reasign:

numbers = []

You can only truncate:

numbers.length = 0