Wie entleere ich ein Array in JavaScript?

Gibt es eine Möglichkeit, ein Array zu leeren und wenn ja, möglicherweise mit .remove()?

Zum Beispiel,

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

Wie kann ich das leeren?

Möglichkeiten zum Löschen eines vorhandenen Arrays A:

Methode 1

(Dies war meine ursprüngliche Antwort auf die Frage)

A = [];

Dieser Code setzt die Variable Aauf ein neues leeres Array. Dies ist perfekt, wenn Sie nirgendwo anders Verweise auf das ursprüngliche Array habenA , da dadurch tatsächlich ein brandneues (leeres) Array erstellt wird. Sie sollten mit dieser Methode vorsichtig sein, da das ursprüngliche Array unverändert bleibt, wenn Sie dieses Array von einer anderen Variablen oder Eigenschaft aus referenziert haben. Verwenden Sie diese Option nur, wenn Sie das Array nur anhand seiner ursprünglichen Variablen referenzieren A.

Dies ist auch die schnellste Lösung.

Dieses Codebeispiel zeigt das Problem, das bei Verwendung dieser Methode auftreten kann:

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

Methode 2 (wie vorgeschlagen durch Matthew Crumley )

A.length = 0

Dadurch wird das vorhandene Array gelöscht, indem seine Länge auf 0 gesetzt wird. Einige haben argumentiert, dass dies möglicherweise nicht in allen Implementierungen von JavaScript funktioniert, es stellt sich jedoch heraus, dass dies nicht der Fall ist. Dies funktioniert auch bei Verwendung des "strengen Modus" in ECMAScript 5, da die Längeneigenschaft eines Arrays eine Lese- / Schreibeigenschaft ist.

Methode 3 (wie vorgeschlagen durch Anthony )

A.splice(0,A.length)

Die Verwendung .splice()funktioniert einwandfrei, aber da die .splice()Funktion ein Array mit allen entfernten Elementen zurückgibt, wird tatsächlich eine Kopie des ursprünglichen Arrays zurückgegeben. Benchmarks legen nahe, dass dies keinerlei Auswirkungen auf die Leistung hat.

Methode 4 (wie vorgeschlagen durch tanguy_k )

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

Diese Lösung ist nicht sehr prägnant und im Gegensatz zu früheren Benchmarks, auf die in der ursprünglichen Antwort verwiesen wurde, auch die langsamste Lösung.

Performance

Von allen Methoden zum Löschen eines vorhandenen Arrays sind die Methoden 2 und 3 in ihrer Leistung sehr ähnlich und viel schneller als Methode 4. Siehe diesen Benchmark .

Wie von Diadistis in ihrer Antwort unten ausgeführt, waren die ursprünglichen Benchmarks, die zur Bestimmung der Leistung der vier oben beschriebenen Methoden verwendet wurden, fehlerhaft. Der ursprüngliche Benchmark verwendete das gelöschte Array erneut, sodass bei der zweiten Iteration ein bereits leeres Array gelöscht wurde.

Der folgende Benchmark behebt diesen Fehler: http://jsben.ch/#/hyj65 . Es zeigt deutlich, dass die Methoden Nr. 2 (Längeneigenschaft) und Nr. 3 (Spleißen) am schnellsten sind (Methode 1 wird nicht gezählt, wodurch das ursprüngliche Array nicht geändert wird).

Dies war ein heißes Thema und hat viele Kontroversen ausgelöst. Es gibt tatsächlich viele richtige Antworten, und da diese Antwort schon sehr lange als akzeptierte Antwort markiert ist, werde ich hier alle Methoden einschließen. Wenn Sie für diese Antwort stimmen, stimmen Sie bitte auch den anderen Antworten zu, auf die ich verwiesen habe.

Wenn Sie das ursprüngliche Array beibehalten müssen, weil Sie andere Verweise darauf haben, die ebenfalls aktualisiert werden sollten, können Sie es löschen, ohne ein neues Array zu erstellen, indem Sie seine Länge auf Null setzen:

A.length = 0;

Hier die am schnellsten funktionierende Implementierung bei gleichem Array ("veränderlich"):

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

Zu Ihrer Information kann es nicht vereinfacht werden while (array.pop()): Die Tests werden fehlschlagen.

FYI Map und Set definieren clear(), es wäre logisch, dies auch clear()für Array zu haben.

TypeScript-Version:

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

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

Hier das aktualisierte jsPerf: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

Eine browserübergreifendere und optimalere Lösung besteht darin, spliceden Inhalt des Arrays A wie folgt zu leeren:

A.splice(0, A.length);

Die Antworten, die nicht weniger als 2739 positive Stimmen haben, sind irreführend und falsch.

Die Frage ist: "Wie leeren Sie Ihr vorhandenes Array?" ZB für A = [1,2,3,4].

1. "Ist A = []die Antwort" zu sagen ist unwissend und absolut falsch. [] == []ist falsch .

   Dies liegt daran, dass diese beiden Arrays zwei separate, individuelle Objekte mit ihren eigenen zwei Identitäten sind, die ihren eigenen Raum in der digitalen Welt einnehmen, jedes für sich.

Angenommen, deine Mutter bittet dich, den Mülleimer zu leeren.

• Sie bringen keine neue ein, als hätten Sie getan, wonach Sie gefragt wurden.
• Stattdessen leeren Sie den Mülleimer.
• Sie ersetzen die gefüllte Dose nicht durch eine neue leere Dose, und Sie nehmen das Etikett "A" nicht von der gefüllten Dose und kleben es wie in auf die neue A = [1,2,3,4]; A = [];

Das Leeren eines Array-Objekts ist die einfachste Sache aller Zeiten:

A.length = 0;

Auf diese Weise ist die Dose unter "A" nicht nur leer, sondern auch so sauber wie neu!

2. Außerdem müssen Sie den Müll nicht von Hand entfernen, bis die Dose leer ist! Sie wurden gebeten, den vorhandenen in einer Runde vollständig zu leeren und den Müll nicht aufzuheben, bis die Dose leer ist, wie in:

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

3. Um Ihre linke Hand nicht auf den Boden des Papierkorbs zu legen und sie mit der rechten oben zu halten, können Sie den Inhalt wie folgt herausziehen:

   A.splice(0, A.length);

Nein, Sie wurden gebeten, es zu leeren:

A.length = 0;

Dies ist der einzige Code, der den Inhalt eines bestimmten JavaScript-Arrays korrekt leert.

Leistungstest:

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

Sie können dies zu Ihrer JavaScript-Datei hinzufügen, damit Ihre Arrays "gelöscht" werden können:

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

Dann können Sie es so verwenden:

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

Oder wenn Sie sicher sein wollen, dass Sie nichts zerstören:

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

Viele Leute denken, Sie sollten native Objekte (wie Array) nicht ändern, und ich bin geneigt, dem zuzustimmen. Bitte entscheiden Sie vorsichtig, wie Sie damit umgehen sollen.

Es gibt viel Verwirrung und Fehlinformationen in Bezug auf die Zeit; Pop / Shift-Leistung sowohl in Antworten als auch in Kommentaren. Die while / pop-Lösung weist (wie erwartet) die schlechteste Leistung auf . Was tatsächlich passiert, ist, dass das Setup für jedes Sample, das das Snippet in einer Schleife ausführt, nur einmal ausgeführt wird. z.B:

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

Ich habe einen neuen Test erstellt, der korrekt funktioniert:

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

Warnung: Selbst in dieser Version des Tests können Sie den tatsächlichen Unterschied nicht erkennen, da das Klonen des Arrays den größten Teil der Testzeit in Anspruch nimmt. Es zeigt immer noch, dass dies spliceder schnellste Weg ist, um das Array zu löschen (ohne []Berücksichtigung, da es zwar der schnellste ist, aber das vorhandene Array nicht tatsächlich löscht).

Wenn Sie an der Speicherzuweisung interessiert sind, können Sie jeden Ansatz mit so etwas wie jsfiddle in Verbindung mit der Timeline-Registerkarte der Chrome Dev Tools vergleichen. Sie sollten das Papierkorbsymbol unten verwenden, um eine Speicherbereinigung nach dem Löschen des Arrays zu erzwingen. Dies sollte Ihnen eine genauere Antwort für den Browser Ihrer Wahl geben. Viele Antworten hier sind alt und ich würde mich nicht auf sie verlassen, sondern wie in der obigen Antwort von @ tanguy_k testen.

(Eine Einführung in die oben genannte Registerkarte finden Sie hier )

Stackoverflow zwingt mich, die jsfiddle zu kopieren, also hier ist es:

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

Und Sie sollten beachten, dass dies vom Typ der Array-Elemente abhängen kann, da Javascript Zeichenfolgen anders verwaltet als andere primitive Typen, ganz zu schweigen von Arrays von Objekten. Der Typ kann beeinflussen, was passiert.

Sie können ganz einfach eine Funktion erstellen, um dies für Sie zu tun, die Länge zu ändern oder sie sogar als Funktion zur Wiederverwendung zum nativen Array hinzuzufügen remove().

Stellen Sie sich vor, Sie haben dieses Array:

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

OK, führen Sie einfach Folgendes aus:

arr.length = 0; //change the length

und das Ergebnis ist:

[] //result

einfache Möglichkeit, ein Array zu leeren ...

Verwenden Sie auch eine Schleife, die nicht erforderlich ist, sondern nur eine andere Möglichkeit, dies zu tun:

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

Es gibt auch schwierige Wege, über die Sie nachdenken können, zum Beispiel so etwas:

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

Wenn arr also 5 Elemente enthält, werden 5 Elemente von 0 gespleißt, was bedeutet, dass nichts im Array verbleibt.

Auch andere Möglichkeiten, wie das Array einfach neu zuzuweisen, zum Beispiel:

arr = []; //[]

Wenn Sie sich die Array-Funktionen ansehen, gibt es viele andere Möglichkeiten, dies zu tun, aber die am meisten empfohlene könnte darin bestehen, die Länge zu ändern.

Wie ich bereits sagte, können Sie auch den Prototyp remove () verwenden, da dies die Antwort auf Ihre Frage ist. Sie können einfach eine der oben genannten Methoden auswählen und sie als Prototyp für ein Array-Objekt in JavaScript erstellen.

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

und Sie können es einfach so nennen, um ein beliebiges Array in Ihrer Javascript-Anwendung zu leeren:

arr.remove(); //[]

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

Und nenne es: array.clear();

A.splice(0);

Ich habe das gerade mit einem Code gemacht, an dem ich arbeite. Es löschte das Array.

Wenn Sie verwenden

a = []; 

Dann weisen Sie a eine neue Array-Referenz zu. Wenn die Referenz in a bereits einer anderen Variablen zugewiesen ist, wird auch dieses Array nicht geleert, und daher sammelt der Garbage Collector diesen Speicher nicht.

Zum Beispiel.

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

oder

a.length = 0;

Wenn wir angeben a.length, setzen wir nur die Grenzen des Arrays zurück und der Speicher für die restlichen Array-Elemente wird durch den Garbage Collector verbunden.

Anstelle dieser beiden Lösungen sind besser.

a.splice(0,a.length)

und

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

Gemäß der vorherigen Antwort von kenshou.html ist die zweite Methode schneller.

Verwenden Sie eine modifizierte Version von Jan 's ursprünglichem Vorschlag:

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

Wenn Sie Konstanten verwenden, haben Sie keine Wahl:

const numbers = [1, 2, 3]

Sie können nicht neu zuweisen:

numbers = []

Sie können nur abschneiden:

numbers.length = 0

Um einen aktuellen Speicherort eines Arrays zu leeren, verwenden Sie: 'myArray.length = 0'oder'myArray.pop() UN-till its length is 0'

• length: Sie können die Eigenschaft length so einstellen, dass ein Array jederzeit abgeschnitten wird. Wenn Sie ein Array durch Ändern seiner Längeneigenschaft erweitern, erhöht sich die Anzahl der tatsächlichen Elemente.
• pop() : Die Pop-Methode entfernt das letzte Element aus einem Array und gibt den entfernten Wert zurück.
• shift(): Die Verschiebungsmethode entfernt das Element am nullten Index und verschiebt die Werte bei aufeinanderfolgenden Indizes nach unten. Anschließend wird der entfernte Wert zurückgegeben.

Beispiel:

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() | [] Erstellen Sie mit Array constructoroder ein Array mit neuem Speicherort 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() : Durch Verwendung der Slice-Funktion erhalten wir eine flache Kopie der Elemente aus dem ursprünglichen Array mit neuer Speicheradresse, sodass Änderungen an cloneArr keine Auswirkungen auf ein tatsächliches | ursprüngliches Array haben.

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

Ich bin überrascht, dass dies noch niemand vorgeschlagen hat:

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

Dies ergibt ein Array in einem ganz anderen Zustand als die anderen Lösungen. In gewisser Weise wurde das Array "geleert":

xs
=> Array [ <4 empty slots> ]

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

xs.length
=> 4

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

Sie können ein äquivalentes Array mit [,,,,]oder erstellenArray(4)

Verwenden Sie unten, wenn Sie Angular 2+ FormArray leeren müssen.

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