Wie lege ich ein Array in JavaScript leer?

Möglichkeiten zum deaktivieren Sie ein vorhandenes array A:

Methode 1

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

A = [];

Dieser code setzt die variable A um ein neues leeres array. Dies ist ideal, wenn Sie nicht haben, Verweise auf das original-array A anderswo wegen dieses tatsächlich schafft ein Marke neues (leeres) array. Sie sollten vorsichtig sein mit dieser Methode, weil, wenn Sie referenziert das array aus einer anderen Variablen oder Eigenschaft, das original-array unverändert bleibt. Verwenden Sie diese Funktion nur, wenn Sie nur Verweis auf die array von seiner ursprünglichen variable A.

Dies ist auch die Schnellste Lösung.

Dieses code-Beispiel zeigt das Problem können Sie begegnen, wenn Sie diese Methode:

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 von Matthäus Crumley)

A.length = 0

Hiermit löschen Sie den vorhandenen array, indem seine Länge auf 0. Einige haben argumentiert, dass dies funktioniert möglicherweise nicht in allen Implementierungen von JavaScript, aber es stellt sich heraus, dass dies nicht der Fall ist. Es funktioniert auch bei der Verwendung von "strict-Modus", in ECMAScript 5, da die length-Eigenschaft eines Arrays ist eine lese - /schreib-Eigenschaft.

Methode 3 (wie vorgeschlagen von Anthony)

A.splice(0,A.length)

Mit .splice() perfekt funktionieren wird, aber da die .splice() Funktion gibt ein array mit allen Elemente entfernt, es wird tatsächlich bringen Sie eine Kopie des ursprünglichen Arrays. Benchmarks legen nahe, dass dies hat keine Auswirkung auf die Leistung zu löschen.

Methode 4 (wie vorgeschlagen von tanguy_k)

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

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

Leistung

Alle Methoden des clearing eine vorhandenen array, Methoden 2 und 3 sind sehr ähnlich in der Leistung und sind sehr viel schneller als mit Methode 4. Sehen Sie diese benchmark.

Wie bereits von Diadistis in Ihrer Antwort unten die original-benchmarks, die verwendet wurden, um zu bestimmen, die Leistung der vier oben beschriebenen Methoden fehlerhaft waren. Der ursprüngliche benchmark wiederverwendet das array gelöscht, so dass die zweite iteration war die Lichtung ein array, das war schon leer.

Den folgenden benchmark behebt dieses Manko: http://jsben.ch/#/hyj65. Es zeigt deutlich, dass die Methoden #2 (Eigenschaft length) und #3 (splice) sind die schnellsten (nicht-zählen-Methode #1 nicht ändern, das ursprüngliche array).

War dies ein heißes Thema und die Ursache von viel Streit. Es gibt tatsächlich viele richtige Antworten und weil diese Antwort markiert wurde als die akzeptierte Antwort für eine sehr lange Zeit, ich werde auch alle Methoden hier. Wenn Sie Stimmen für diese Antwort, bitte upvote die anderen Antworten, habe ich verwiesen.

InformationsquelleAutor der Antwort Philippe Leybaert

Hier die Schnellste Umsetzung arbeiten , während halten, die das gleiche array ("veränderlich"):

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

FYI Anzeigen definiert clear() so würde es logisch erscheinen, haben clear() für Array zu.

Oder als Underscore.js mixin:

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

Oder eine einfache Funktion:

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

Typoskript version:

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

Zur info es kann nicht vereinfacht werden, um while (array.pop()): der Test schlägt fehl.

Und die tests, die mit ihm geht:

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

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

InformationsquelleAutor der Antwort tanguy_k

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

InformationsquelleAutor der Antwort kenshou.html

Können Sie fügen Sie diese, um Ihre JavaScript-Datei zu ermöglichen, Ihren arrays eine "Freigabe":

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

Dann können Sie es verwenden, wie diese:

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

Oder wenn Sie wollen sicher sein, Sie nicht zu zerstören, etwas:

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

Viele Leute denken, Sie sollten nicht ändern, native Objekte (wie Array), und ich bin geneigt zu vereinbaren. Bitte seien Sie vorsichtig bei der Entscheidung, wie Sie damit umgehen können.

InformationsquelleAutor der Antwort leech

Falls Sie interessiert sind, in die Speicher-Zuordnung, die können Sie vergleichen, jeder Ansatz mit so etwas wie dieses jsfiddle in Verbindung mit den chrome dev tools " der Registerkarte timeline. Möchten Sie den Papierkorb-Symbol am unteren Rand eine Kraft, die eine garbage collection nach dem "clearing" der array. Dies sollte Ihnen eine endgültige Antwort für den browser Ihrer Wahl. Viele Antworten hier sind alt, und ich würde nicht auf Sie verlassen, sondern testen, wie in @tanguy_k die Antwort von oben.

(für ein intro auf der oben genannten Registerkarte, die Sie heraus überprüfen können hier)

Stackoverflow zwingt mich dazu kopieren Sie die jsfiddle 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 zur Kenntnis nehmen, dass es möglicherweise abhängen, die den Typ der array-Elemente, die als javascript-strings verwaltet anders als andere primitive Typen, nicht zu erwähnen, arrays von Objekten. Der Typ kann beeinflussen, was passiert.

InformationsquelleAutor der Antwort matanster

A.splice(0);

Habe ich nur dieses auf einige code an dem ich arbeite. Es machte den array.

InformationsquelleAutor der Antwort David Campbell

Verwenden eine modifizierte version von Jan's ersten Vorschlag:

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

InformationsquelleAutor der Antwort cssimsek

Können Sie leicht eine Funktion erstellen, um das für Sie tun, ändern Sie die Länge oder sogar fügen Sie es zu native Array - als die remove () - Funktion für die Wiederverwendung.

Stellen Sie sich vor Sie haben dieses array:

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

OK, nur führen Sie einfach diese:

arr.length = 0; //change the length

und das Ergebnis ist:

[] //result

einfache Möglichkeit, ein array leer...

Auch mithilfe der Schleife, das ist nicht notwendig, sondern nur ein weiterer 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(); 
  }
}

Gibt es auch knifflige Art und Weise, die Sie denken können, zum Beispiel so etwas wie dieses:

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

Also, wenn arr hat 5 Elemente, es wird splice 5 Positionen von 0, was bedeutet, dass nichts bleiben wird, in dem array.

Auch andere Möglichkeiten wie weisen Sie einfach die array-Beispiel:

arr = []; //[]

Wenn man sich die Array-Funktionen, es gibt viele andere Möglichkeiten, dies zu tun, aber die meisten empfehlen könne man die änderung der Länge.

Wie gesagt in den ersten Platz, Sie können auch Prototypen remove (), wie es die Antwort auf Ihre Frage. Sie können wählen Sie einfach eine der oben genannten Methoden und Prototypen, die es zu Array-Objekt in JavaScript, so etwas wie:

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

und rufen Sie einfach an, wie diese zu leeren Arrays, die Sie in Ihrem javascript-Anwendung:

arr.remove(); //[]

InformationsquelleAutor der Antwort Alireza

Leer einer Aktuellen Speicherbereich eines Arrays verwenden: 'myArray.length = 0' oder 'myArray.pop() UN-till its length is 0'

• length : Sie können die Eigenschaft Länge abschneiden, ein array zu jeder Zeit. Beim erweitern eines Arrays, indem Sie seine Eigenschaft length, die die Anzahl der tatsächlichen Elemente erhöht.
• pop() : Die pop-Methode entfernt die letzten element aus einem array und gibt liefert den Wert entfernt.
• shift() : Die shift-Methode entfernt das element an der zeroeth index und Verschiebungen der Werte bei aufeinander folgenden Indizes nach unten, dann gibt der Wert entfernt werden.

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 den neuen Speicherbereich durch Verwendung Array constructor oder 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 die Verwendung der slice-Funktion erhalten wir eine flache Kopie von Elementen des ursprünglichen Arrays, mit neuen Speicher-Adresse, So dass jede änderung am cloneArr wird nicht auf einer tatsächlichen|original-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);

InformationsquelleAutor der Antwort Yash