Domanda Come svuoto 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 svuotare quello?


2199
2017-08-05 09:08


origine


risposte:


Modi per cancellare un array esistente A:

Metodo 1

(questa era la mia risposta originale alla domanda)

A = [];

Questo codice imposterà la variabile A a un nuovo array vuoto. Questo è perfetto se non lo hai riferimenti alla matrice originale A da qualsiasi altra parte, perché in realtà questo crea una nuova (vuota) matrice. Si dovrebbe fare attenzione con questo metodo perché se si fa riferimento a questa matrice da un'altra variabile o proprietà, la matrice originale rimarrà invariata. Usalo solo se fai riferimento alla matrice solo tramite la sua variabile originale A.

Questa è anche la soluzione più veloce.

Questo esempio di codice mostra il problema che puoi riscontrare quando usi 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 di Matthew Crumley)

A.length = 0

Questo cancellerà l'array esistente impostandone la lunghezza a 0. Alcuni hanno sostenuto che questo potrebbe non funzionare in tutte le implementazioni di JavaScript, ma risulta che non è questo il caso. Funziona anche quando si utilizza "strict mode" in ECMAScript 5 perché la proprietà length di un array è una proprietà read / write.

Metodo 3 (come suggerito di Anthony)

A.splice(0,A.length)

utilizzando .splice() funzionerà perfettamente, ma dal momento che .splice() la funzione restituirà un array con tutti gli elementi rimossi, in realtà restituirà una copia dell'array originale. I benchmark suggeriscono che ciò non ha alcun effetto sulla performance.

Metodo 4 (come suggerito di tanguy_k)

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

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

Prestazione

Di tutti i metodi di compensazione di matrice esistente, i metodi 2 e 3 sono molto simili nelle prestazioni e sono molto più veloci del metodo 4. Vedi questo segno di riferimento.

Come sottolineato da Diadistis nel loro risposta di seguito, i benchmark originali utilizzati per determinare le prestazioni dei quattro metodi sopra descritti erano imperfetti. Il benchmark originale riutilizzava l'array cancellato in modo che la seconda iterazione cancellasse una matrice che era già vuota.

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 modifica l'array originale).


Questo è stato un argomento scottante e causa di molte polemiche. Ci sono in realtà molte risposte corrette e poiché questa risposta è stata contrassegnata come risposta accettata per un tempo molto lungo, includerò tutti i metodi qui. Se si vota per questa risposta, si prega di aggiornare le altre risposte a cui ho fatto riferimento.


3439
2017-08-05 09:10



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

A.length = 0;

2253
2017-08-05 16:29



Qui l'implementazione di lavoro più rapida mentre mantenendo lo stesso array ("mutevole"):

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

FYI Carta geografica definisce clear() quindi sembrerebbe logico avere clear() per schieramento pure.

O come un Underscore.js mixin:

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

O una semplice funzione:

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

Dattiloscritto versione:

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

FYI non può essere semplificato a while (array.pop()): i test falliranno.

E i test che lo accompagnano:

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

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


255
2018-06-25 20:32



Una soluzione più cross-browser friendly e più ottimale sarà usare il splice metodo per svuotare il contenuto dell'array A come di seguito:

A.splice(0, A.length);


182
2017-11-15 09:49



Le risposte che non hanno di meno che i 2739 upvotes di adesso sono fuorvianti e scorretti.

La domanda è: "Come svuoti il ​​tuo array esistente?" Per esempio. per A = [1,2,3,4].

  1. Detto "A = [] è la risposta "è ignorante e assolutamente scorretto. [] == [] è falso.

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


Diciamo che tua madre ti chiede di svuotare il bidone della spazzatura.

  • Non ne porti uno nuovo come se avessi fatto quello che ti è stato chiesto.
  • Invece, si svuota il cestino.
  • Non sostituisci quello riempito con una nuova lattina vuota, e non prendi l'etichetta "A" dalla lattina piena e incollala alla 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, il barattolo sotto "A" non è solo vuoto, ma anche pulito come nuovo!


  1. Inoltre, non è necessario rimuovere la spazzatura a mano fino a quando il barattolo è vuoto! Ti è stato chiesto di svuotare quello esistente, completamente, in un turno, di non raccogliere la spazzatura finché la scatola non si svuota, come in:

    while(A.length > 0) {
        A.pop();
    }
    
  2. Né, per mettere la mano sinistra nella parte inferiore della spazzatura, tenendola con la destra in alto per poterne estrarre il 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.


61
2018-04-30 15:18



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

59
2018-05-14 07:14



È possibile aggiungerlo al file JavaScript per consentire la "cancellazione" degli array:

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 si debbano modificare oggetti nativi (come Array) e sono propenso a concordare. Si prega di usare cautela nel decidere come gestirlo.


32
2017-12-11 02:58



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

E chiamalo: array.clear();


16
2018-02-22 21:28



C'è un sacco di confusione e disinformazione per quanto riguarda il tempo: prestazioni pop / shift sia nelle risposte che nei commenti. La soluzione while / pop ha (come previsto) il peggiore prestazione. Quello che succede in realtà è 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

Avvertimento: anche in questa versione del test non si può realmente vedere la vera differenza perché la clonazione dell'array occupa la maggior parte del tempo di test. Lo dimostra ancora splice è il modo più veloce per cancellare l'array (non prendere [] in considerazione perché mentre è il più veloce in realtà non sta cancellando l'array esistente).


15
2018-02-16 18:52



Nel caso in cui sei interessato all'assegnazione della memoria, puoi confrontare ogni approccio usando qualcosa di simile questo jsfiddle in combinazione con la scheda Timeline degli strumenti di chrome dev. Dovrai utilizzare l'icona del cestino nella parte inferiore per forzare una garbage collection dopo aver "cancellato" l'array. Questo dovrebbe darti una risposta più precisa per il browser di tua scelta. Molte risposte qui sono vecchie e non mi affiderei a loro, ma piuttosto test come nella risposta di @ tanguy_k sopra.

(per un'introduzione alla scheda sopra menzionata è possibile effettuare il check out Qui)

Stackoverflow mi obbliga a copiare il jsfiddle così 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 prendere nota che può dipendere dal tipo di elementi dell'array, dato che javascript gestisce stringhe in modo diverso rispetto ad altri tipi primitivi, per non parlare degli array di oggetti. Il tipo può influenzare ciò che accade.


14
2017-12-11 23:19



A.splice(0);

L'ho appena fatto su un codice su cui sto lavorando. Ha eliminato l'array.


10
2018-01-29 19:24