Come posso svuotare un array in JavaScript?

C'è un modo per svuotare un array e, se possibile, con .remove()?

Per esempio,

A = [1,2,3,4];

Come posso svuotarlo?

Modi per cancellare un array esistente A:

Metodo 1

(questa era la mia risposta originale alla domanda)

A = [];

Questo codice imposterà la variabile Asu un nuovo array vuoto. Questo è perfetto se non si hanno riferimenti all'array originaleA altrove perché in realtà crea un array nuovo (vuoto). Dovresti stare attento con questo metodo perché se hai fatto riferimento a questo array da un'altra variabile o proprietà, l'array originale rimarrà invariato. Utilizzalo solo se fai riferimento all'array solo con la sua variabile originale A.

Questa è anche la soluzione più veloce.

Questo esempio di codice mostra il problema che si può verificare durante l'utilizzo di questo metodo:

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

Metodo 2 (come suggerito da Matthew Crumley )

A.length = 0

Questo cancellerà l'array esistente impostando la sua lunghezza su 0. Alcuni hanno sostenuto che questo potrebbe non funzionare in tutte le implementazioni di JavaScript, ma si scopre che non è così. Funziona anche quando si utilizza la "modalità rigorosa" in ECMAScript 5 perché la proprietà length di un array è una proprietà read / write.

Metodo 3 (come suggerito da Anthony )

A.splice(0,A.length)

L'uso .splice()funzionerà perfettamente, ma poiché la .splice()funzione restituirà un array con tutti gli elementi rimossi, restituirà effettivamente una copia dell'array originale. I benchmark suggeriscono che ciò non ha alcun effetto sulle prestazioni.

Metodo 4 (come suggerito da tanguy_k )

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

Questa soluzione non è molto concisa, ed è anche la soluzione più lenta, contrariamente ai benchmark precedenti a cui si fa riferimento nella risposta originale.

Prestazione

Di tutti i metodi per cancellare un array esistente , i metodi 2 e 3 sono molto simili nelle prestazioni e sono molto più veloci del metodo 4. Vedi questo benchmark .

Come sottolineato da Diadistis nella loro risposta di seguito, i parametri di riferimento originali utilizzati per determinare le prestazioni dei quattro metodi sopra descritti erano imperfetti. Il benchmark originale ha riutilizzato l'array eliminato, quindi la seconda iterazione stava eliminando un array che era già vuoto.

Il seguente benchmark corregge questo difetto: http://jsben.ch/#/hyj65 . Mostra chiaramente che i metodi # 2 (proprietà length) e # 3 (splice) sono i più veloci (senza contare il metodo # 1 che non cambia l'array originale).

Questo è stato un argomento caldo e causa di molte controversie. In realtà ci sono molte risposte corrette e poiché questa risposta è stata contrassegnata come risposta accettata per molto tempo, includerò qui tutti i metodi. Se voti per questa risposta, per favore vota anche le altre risposte a cui ho fatto riferimento.

Se è necessario mantenere l'array originale perché ci sono altri riferimenti che dovrebbero essere aggiornati, è possibile cancellarlo senza creare un nuovo array impostando la lunghezza su zero:

A.length = 0;

Qui l'implementazione più veloce di lavoro pur mantenendo lo stesso array ( "mutabile"):

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

Cordiali saluti non può essere semplificato while (array.pop()): i test falliranno.

FYI Map e Set definiscono clear(), sarebbe logico avere anche clear()per Array .

Versione TypeScript:

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

I test corrispondenti:

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

Qui il jsPerf aggiornato: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

Una soluzione più cross-browser e più ottimale sarà quella di utilizzare il splicemetodo per svuotare il contenuto dell'array A come di seguito:

A.splice(0, A.length);

Le risposte che non hanno ora meno di 2739 voti sono fuorvianti e errate.

La domanda è: "Come svuoti l'array esistente?" Ad esempio per A = [1,2,3,4].

1. Dire " A = []è la risposta" è ignorante e assolutamente errato. [] == []è falso .

   Questo perché questi due array sono due oggetti separati, individuali, con le loro due identità, che occupano il loro spazio nel mondo digitale, ognuno per conto proprio.

Diciamo che tua madre ti chiede di svuotare il cestino.

• Non ne porti uno nuovo come se avessi fatto ciò che ti era stato chiesto.
• Invece, svuoti il ​​cestino.
• Non si sostituisce quello riempito con una nuova lattina vuota e non si prende l'etichetta "A" dalla lattina riempita e si attacca a quella nuova come in A = [1,2,3,4]; A = [];

Svuotare un oggetto array è la cosa più semplice di sempre:

A.length = 0;

In questo modo, la lattina sotto "A" non è solo vuota, ma anche pulita come nuova!

2. Inoltre, non è necessario rimuovere manualmente la spazzatura finché la lattina non è vuota! Ti è stato chiesto di svuotare quello esistente, completamente, in un turno, per non raccogliere la spazzatura fino a quando la lattina non si svuota, come in:

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

3. Né, per mettere la mano sinistra nella parte inferiore della spazzatura, tenendola con la destra in alto per poter estrarre il suo contenuto come in:

   A.splice(0, A.length);

No, ti è stato chiesto di svuotarlo:

A.length = 0;

Questo è l'unico codice che svuota correttamente il contenuto di un determinato array JavaScript.

Test della prestazione:

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

Puoi aggiungerlo al tuo file JavaScript per consentire la "cancellazione" delle matrici:

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

Quindi puoi usarlo in questo modo:

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

O se vuoi essere sicuro di non distruggere qualcosa:

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

Molte persone pensano che non dovresti modificare oggetti nativi (come Array), e sono propenso a concordare. Si prega di usare cautela nel decidere come gestirlo.

C'è un sacco di confusione e disinformazione riguardo al tempo; prestazioni pop / shift sia nelle risposte che nei commenti. La soluzione while / pop ha (come previsto) le prestazioni peggiori . Quello che sta realmente accadendo è che l'installazione viene eseguita una sola volta per ogni campione che esegue lo snippet in un ciclo. per esempio:

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

Ho creato un nuovo test che funziona correttamente:

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

Avvertenza: anche in questa versione del test non è possibile vedere la vera differenza perché la clonazione dell'array impiega la maggior parte del tempo di test. Indica ancora che spliceè il modo più veloce per cancellare l'array (non tenendo []in considerazione perché mentre è il più veloce non sta effettivamente cancellando l'array esistente).

Se sei interessato all'allocazione della memoria, puoi confrontare ogni approccio usando qualcosa come questo jsfiddle in congiunzione con la scheda della timeline degli strumenti di sviluppo di Chrome. Si consiglia di utilizzare l'icona del cestino in basso per forzare una raccolta di rifiuti dopo aver 'cancellato' l'array. Questo dovrebbe darti una risposta più definita per il browser che preferisci. Molte risposte qui sono vecchie e non mi affiderei a loro, ma piuttosto testerei come nella risposta di @ tanguy_k sopra.

(per un'introduzione alla scheda di cui sopra è possibile controllare qui )

Stackoverflow mi costringe a copiare il jsfiddle quindi eccolo qui:

<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 dovresti notare che potrebbe dipendere dal tipo di elementi dell'array, poiché javascript gestisce le stringhe in modo diverso rispetto ad altri tipi primitivi, per non parlare delle matrici di oggetti. Il tipo può influire su ciò che accade.

Puoi facilmente creare una funzione per farlo, cambiare la lunghezza o persino aggiungerla all'array nativo come remove()funzione per il riutilizzo.

Immagina di avere questo array:

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

OK, esegui semplicemente questo:

arr.length = 0; //change the length

e il risultato è:

[] //result

modo semplice per svuotare un array ...

Usando anche il loop che non è necessario ma solo un altro modo per farlo:

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

Ci sono anche modi difficili a cui puoi pensare, ad esempio qualcosa del genere:

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

Quindi, se arr ha 5 oggetti, ne separerà 5 da 0, il che significa che nulla rimarrà nell'array.

Anche altri modi come semplicemente riassegnare l'array per esempio:

arr = []; //[]

Se si osservano le funzioni dell'array, esistono molti altri modi per farlo, ma quello più consigliato potrebbe essere la modifica della lunghezza.

Come ho detto in primo luogo, puoi anche prototipare remove () in quanto è la risposta alla tua domanda. puoi semplicemente scegliere uno dei metodi sopra e prototiparlo sull'oggetto Array in JavaScript, qualcosa del tipo:

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

e puoi semplicemente chiamarlo così per svuotare qualsiasi array nella tua applicazione javascript:

arr.remove(); //[]

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

E chiamalo: array.clear();

A.splice(0);

Ho appena fatto questo su un codice su cui sto lavorando. Ha cancellato l'array.

Se stai usando

a = []; 

Quindi stai assegnando un nuovo riferimento di array a a, se il riferimento in a è già assegnato a qualsiasi altra variabile, allora non svuoterà anche quell'array e quindi Garbage Collector non raccoglierà quella memoria.

Per es.

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

o

a.length = 0;

Quando specifichiamo a.length, stiamo solo ripristinando i limiti dell'array e la memoria per gli elementi dell'array restanti sarà connessa da Garbage Collector.

Invece di queste due soluzioni sono migliori.

a.splice(0,a.length)

e

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

Secondo la precedente risposta di kenshou.html, il secondo metodo è più veloce.

Usa una versione modificata del suggerimento iniziale di Jan :

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

Se usi le costanti, non hai scelta:

const numbers = [1, 2, 3]

Non puoi riassegnare:

numbers = []

Puoi solo troncare:

numbers.length = 0

Per svuotare una posizione di memoria corrente di un array usare: 'myArray.length = 0'o'myArray.pop() UN-till its length is 0'

• length: È possibile impostare la proprietà length per troncare un array in qualsiasi momento. Quando si estende un array modificandone la proprietà length, aumenta il numero di elementi effettivi.
• pop() : Il metodo pop rimuove l' ultimo elemento da un array e restituisce il valore restituito.
• shift(): Il metodo shift rimuove l'elemento sull'indice zero e sposta i valori su indici consecutivi verso il basso, quindi restituisce il valore rimosso.

Esempio:

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() | [] Creare un array con una nuova posizione di memoria utilizzando Array constructoro 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 la funzione slice otteniamo una copia superficiale degli elementi dall'array originale, con un nuovo indirizzo di memoria, in modo che qualsiasi modifica su cloneArr non influisca su un array | originale originale.

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

Sono sorpreso che nessuno l'abbia ancora suggerito:

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

Questo produce un array in uno stato abbastanza diverso dalle altre soluzioni. In un certo senso, l'array è stato "svuotato":

xs
=> Array [ <4 empty slots> ]

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

xs.length
=> 4

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

È possibile produrre un array equivalente con [,,,,]oArray(4)

Utilizzare di seguito se è necessario svuotare Angular 2+ FormArray.

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