Como é que esvazio um array em JavaScript?

Se precisar de manter a matriz original porque tem outras referências a ela que também devem ser actualizadas, poderá limpá-la sem criar uma nova matriz, ajustando o seu comprimento para zero:

A.length = 0;

aqui a implementação de trabalho mais rápido enquanto mantém o mesmo array ("mutável"):

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

FYI Map define clear() por isso parece lógico ter clear() para Array também.

Ou como sublinhado.js mixin:

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

Ou uma função simples:

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

TypeScript version:

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

Para que saibas, não pode ser simplificado para while (array.pop()): Os testes vão falhar.

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

Aqui atualizado jsPerf: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

Uma solução mais amigável e mais óptima será usar o método splice para esvaziar o conteúdo do array A como abaixo:

A.splice(0, A.length);

As respostas que não têm menos que 2739 upvotes agora são enganosas e incorretas.

A questão é: "como se esvazia a matriz existente?"Por exemplo, para A = [1,2,3,4].

1. Dizer "é a resposta" é ignorante e absolutamente incorreto. [] == [] é falso . Isto é porque estas duas matrizes são dois objectos individuais separados, com as suas duas identidades, ocupando o seu próprio espaço no mundo digital, cada um no seu proprio.

Não trazes um novo como se tivesses feito o que te pediram. Em vez disso, esvazia o caixote do lixo.
• não se substitui o cheio por uma lata nova e vazia, e não se pega no rótulo " A " da lata cheia e coloca-se na nova como em A = [1,2,3,4]; A = [];

A.length = 0;

1. Além disso, não é necessário remover o lixo à mão até que a lata esteja vazia! Foi-lhe pedido que esvaziasse a existente, completamente, de uma vez, para não recolher o lixo até que a lata fique vazia, como em:

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

2. Nem, para colocar a mão esquerda no fundo do lixo, segurando-a com a direita no topo para ser capaz de retirar o seu conteúdo como in:

   A.splice(0, A.length);
   

A.length = 0;

Este é o único código que esvazia correctamente o conteúdo de um dado array JavaScript.

Ensaio de desempenho:

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

Pode adicionar isto ao seu ficheiro JavaScript para permitir que as suas matrizes sejam "limpas":

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

Então você pode usá-lo assim:

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

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

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

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

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

Aviso: mesmo neste versão do teste você não pode realmente ver a diferença real porque a clonagem do array ocupa a maior parte do tempo de teste. Ele ainda mostra que splice é a maneira mais rápida de limpar o array (não levando [] em consideração porque embora seja o mais rápido não está realmente limpando o array existente).

No caso de estar interessado na alocação de memória, poderá comparar cada abordagem usando algo como Este jsfiddle em conjunto com a página de linha temporal do dev do chrome. Você vai querer usar o ícone do caixote do lixo no fundo para forçar uma coleção de lixo depois de 'limpar' a matriz. Isto deve dar - lhe uma resposta mais definida para o navegador de sua escolha. Muitas respostas aqui são antigas e eu não confiaria nelas, mas sim testar como na resposta de @tanguy_k acima.

(para uma introdução à página acima mencionada, você pode verificar Aqui)

O Stackoverflow obriga-me a copiar o jsfiddle, por isso aqui está:

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

E você deve ter em atenção que ele pode depender do tipo de elementos de array, como javascript gerencia strings de forma diferente de outros tipos primitivos, para não mencionar arrays de objetos. O tipo pode afetar o que acontece.

A.splice(0);

Se estiver a utilizar

a = []; 

Então você está atribuindo nova matriz de referência a a, se a referência em a já está atribuída a qualquer outra variável, então ela não vai esvaziar essa matriz também e, portanto, coletor de lixo não vai coletar essa memória.

Para ex.

var a=[1,2,3];
var b=a;
a=[];
console.log(b);// It will print [1,2,3];

Ou

a.length = 0;

Quando especificamos a.length, estamos apenas a redefinir os limites do array e a memória para o descanso os elementos do array serão ligados pelo coletor de lixo.

a.splice(0,a.length)

E

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

Utilize uma versão modificada da sugestão inicial de Jan:

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

Se usar constantes, não tem escolha:

const numbers = [1, 2, 3]

Não podes mudar de assunto:

numbers = []

Só podes truncar:

numbers.length = 0

Você pode facilmente criar uma função para fazer isso por si, alterar o Comprimento ou até mesmo adicioná-lo a matriz nativa como remove() função para reutilização.

Imagine que tem esta matriz:

var arr = [1, 2, 3, 4, 5]; //the array

arr.length = 0; //change the length

E o resultado é:

[] //result

Maneira fácil de esvaziar uma matriz...

Também usando loop que não é necessário, mas apenas outra maneira de fazer isso:

/* could be arr.pop() or arr.splice(0)
don't need to return as main array get changed */

function remove(arr) {
  while(arr.length) {
    arr.shift(); 
  }
}

arr.splice(0, arr.length); //[]

Então se o arr tem 5 itens, ele irá juntar 5 itens de 0, o que significa que nada vai permanecer na matriz.

Também outras formas como simplesmente reatribuir a matriz por exemplo:

arr = []; //[]

Se você olhar para as funções de Array, existem muitas outras maneiras de fazer isso, mas o mais recomendado pode ser mudar o comprimento.

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

E você pode simplesmente chamá-lo assim para esvaziar qualquer array na sua aplicação javascript:

arr.remove(); //[]

let xs = [1,2,3,4];
for (let i in xs)
    delete xs[i];

Isto produz uma matriz em um estado completamente diferente das outras soluções. De certa forma, a matriz foi "esvaziada":

xs
=> Array [ <4 empty slots> ]

[...xs]
=> Array [ undefined, undefined, undefined, undefined ]

xs.length
=> 4

xs[0]
=> ReferenceError: reference to undefined property xs[0]

Pode produzir uma matriz equivalente com [,,,,] ou Array(4)

para esvaziar uma localização actual de memória de uma lista, use: 'myArray.length = 0' ou 'myArray.pop() UN-till its length is 0'

• length : Você pode definir a propriedade de comprimento para truncar um array a qualquer momento. Quando você extende um array alterando sua propriedade de comprimento, o número de elementos reais aumenta.
• pop() : o método pop remove o último elemento de uma lista e devolve o que devolve o removido valor.
• shift() : o método shift remove o elemento do Índice zeroeth e desloca os valores em índices consecutivos para baixo, retornando depois o valor removido.

Exemplo:

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() | [] crie um Array com nova localização de memória usando Array constructor ou 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() : usando a função de fatia obtemos uma cópia rasa dos elementos do original array, com novo endereço de memória, de modo que qualquer modificação no cloneArr não afetará um array real|original.

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

Utilize em baixo se necessitar de esvaziar o formato Angular 2+.

public emptyFormArray(formArray:FormArray) {
    for (let i = formArray.controls.length - 1; i >= 0; i--) {
        formArray.removeAt(i);
    }
}