it-swarm.com.de

Wie leere 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?

2199
akano1

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 A auf ein neues leeres Array. Dies ist perfekt, wenn Sie nirgendwo anders Verweise auf das ursprüngliche Array A haben, da hierdurch 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 referenziert haben. Verwenden Sie dies nur, wenn Sie das Array nur anhand seiner ursprünglichen Variablen A referenzieren.

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 (als vorgeschlagen von Matthew Crumley )

A.length = 0

Dadurch wird das vorhandene Array gelöscht, indem die 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 length-Eigenschaft eines Arrays eine Lese-/Schreibeigenschaft ist.

Methode 3 (als vorgeschlagen von Anthony )

A.splice(0,A.length)

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

Methode 4 (als vorgeschlagen von 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.

Leistung

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

Wie von Diadistis in ihrer Antwort unten hervorgehoben, 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 . Dies zeigt deutlich, dass die Methoden Nr. 2 (Längeneigenschaft) und Nr. 3 (Spleiß) am schnellsten sind (ohne die Methode Nr. 1 zu zählen, die das ursprüngliche Array nicht ändert).


Dies war ein heißes Thema und Anlass für viele Kontroversen. Es gibt tatsächlich viele richtige Antworten, und da diese Antwort seit langer Zeit als akzeptierte Antwort markiert ist, werde ich hier alle Methoden einbeziehen. Wenn Sie für diese Antwort stimmen, stimmen Sie bitte den anderen Antworten zu, auf die ich ebenfalls verwiesen habe.

4034

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

A.length = 0;
2375
Matthew Crumley

Hier die am schnellsten arbeitende Umsetzung während das gleiche Array behalten ("veränderlich"):

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

Zu Ihrer Information, es kann nicht auf while (array.pop()) vereinfacht werden: Die Tests schlagen fehl.

FYI Map und Set definieren clear(), es wäre logisch, clear() auch 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 der aktualisierte jsPerf: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

276
tanguy_k

Eine browserübergreifendere und optimalere Lösung ist die Verwendung der splice -Methode, um den Inhalt des Arrays A wie folgt zu leeren:

A.splice(0, A.length);

204
Anthony

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

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

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

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


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

  • Sie bringen keine neue mit, 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 nicht das Etikett "A" von der gefüllten Dose und kleben es auf die neue wie in A = [1,2,3,4]; A = [];

Ein Array-Objekt zu leeren 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!


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

    while(A.length > 0) {
        A.pop();
    }
    
  2. Um die linke Hand nicht am unteren Rand des Papierkorbs abzulegen, halten Sie sie mit der rechten Hand nach oben, um den Inhalt wie folgt herausziehen zu können:

    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.

81
Bekim Bacaj

Leistungstest:

http://jsperf.com/array-clear-methods/

a = []; // 37% slower
a.length = 0; // 89% slower
a.splice(0, a.length)  // 97% slower
while (a.length > 0) {
    a.pop();
} // Fastest
63
kenshou.html

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

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

Dann kannst du es so benutzen:

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

Oder wenn Sie sicher gehen 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 seien Sie vorsichtig, wenn Sie entscheiden, wie Sie damit umgehen.

36
leech

Es gibt eine Menge Verwirrung und Fehlinformationen in Bezug auf die Zeit, Pop-/Shift-Performance 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 Setup nur einmal für jedes Beispiel ausgeführt wird, das das Snippet in einer Schleife ausführt. 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 Testversion können Sie den tatsächlichen Unterschied nicht erkennen, da das Klonen des Arrays die meiste Testzeit in Anspruch nimmt. Es zeigt immer noch, dass splice der schnellste Weg zum Löschen des Arrays ist (ohne Berücksichtigung von [], da es zwar der schnellste ist, aber das vorhandene Array nicht wirklich löscht).

18
Diadistis

Wenn Sie an der Speicherzuordnung interessiert sind, können Sie jeden Ansatz mit etwas wie this jsfiddle in Verbindung mit dem Zeitleisten-Tab von chrome dev tools vergleichen. Sie sollten das Papierkorbsymbol unten verwenden, um eine Speicherbereinigung zu erzwingen, nachdem Sie das Array "geleert" haben. 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 @ tanguy_ks Antwort oben testen.

(für eine Einführung in die oben genannte Registerkarte können 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 Strings anders verwaltet als andere primitive Typen, ganz zu schweigen von Arrays von Objekten. Der Typ kann Einfluss darauf haben, was passiert.

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

Und nenne es: array.clear();

14
Bendegúz

A.splice(0);

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

12
David Campbell

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

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 einen anderen Weg, 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 knifflige Möglichkeiten, über die Sie nachdenken können, zum Beispiel:

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

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

Es gibt auch andere Möglichkeiten, wie beispielsweise das Array einfach neu zuzuweisen:

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 in JavaScript als Array-Objekt prototypisieren. Beispiel:

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

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

arr.remove(); //[]
11
Alireza

Wenn Sie verwenden

a = []; 

Anschließend 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 der Garbage Collector erfasst 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 a.length angeben, setzen wir nur die Grenzen des Arrays zurück, und der Speicher für die restlichen Array-Elemente wird vom 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.

11
Laxmikant Dange

Verwenden Sie eine modifizierte Version des ursprünglichen Vorschlags von Jan :

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

Wenn Sie Konstanten verwenden, haben Sie keine Wahl:

const numbers = [1, 2, 3]

Sie können nicht neu zuweisen:

numbers = []

Sie können nur kürzen:

numbers.length = 0
6
Damjan Pavlica

Ich bin überrascht, dass noch niemand dies 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 Array(4) erzeugen.

4
Cauterite

enter image description here

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 length -Eigenschaft 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 shift-Methode entfernt das Element am zeroeth-Index und verschiebt die Werte bei aufeinanderfolgenden Indizes nach unten und gibt dann den entfernten zurück Wert.

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 ein Array mit neuem Speicherort, indem Sie Array constructor oder array literal verwenden.

    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() : Mit der Slice-Funktion erhalten wir eine flache Kopie der Elemente aus dem ursprünglichen Array mit neuer Speicheradresse, sodass sich Änderungen an cloneArr nicht auf eine tatsächliche | auswirken ursprüngliches 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);
    
4
Yash