Löschen von Array-Elementen in JavaScript - Löschen vs. Spleißen

Question

Was ist der Unterschied zwischen der Verwendung von die delete Betreiber auf das Array-Element im Gegensatz zur Verwendung von die Array.splice Methode ?

Zum Beispiel:

myArray = ['a', 'b', 'c', 'd'];

delete myArray[1];
//  or
myArray.splice (1, 1);

Warum überhaupt die Splice-Methode, wenn ich Array-Elemente löschen kann, wie ich mit Objekten kann?

Answer 1

Es handelt sich um unterschiedliche Dinge, die unterschiedliche Zwecke verfolgen.

splice ist array-spezifisch und entfernt, wenn es zum Löschen verwendet wird, Einträge aus dem Array y verschiebt alle vorherigen Einträge nach oben, um die Lücke zu füllen. (Sie kann auch zum Einfügen von Einträgen oder für beides gleichzeitig verwendet werden). splice wird die length des Arrays (vorausgesetzt, es handelt sich nicht um einen No-op-Aufruf: theArray.splice(x, 0) ).

delete ist nicht array-spezifisch; es ist für die Verwendung auf Objekten konzipiert: Es entfernt eine Eigenschaft (Schlüssel/Wert-Paar) aus dem Objekt, für das Sie es verwenden. Es gilt nur für Arrays, weil standardmäßige (z.B. nicht typisierte) Arrays in JavaScript sind eigentlich gar keine Arrays *Es handelt sich um Objekte mit spezieller Behandlung bestimmter Eigenschaften, z. B. solche, deren Namen "Array-Indizes" sind (die definiert als String-Namen "...deren numerischer Wert i liegt in dem Bereich +0 i < 2^32-1 ") und length . Wenn Sie delete um einen Array-Eintrag zu entfernen, wird lediglich der Eintrag entfernt; andere Einträge, die darauf folgen, werden nicht nach oben verschoben, um die Lücke zu füllen, so dass das Array "spärlich" wird (es fehlen einige Einträge ganz). Es hat keinen Effekt auf length .

In einigen der aktuellen Antworten auf diese Frage wird fälschlicherweise behauptet, dass die Verwendung von delete " setzt den Eintrag auf undefined ". Das ist nicht richtig. Es beseitigt den Eintrag (die Eigenschaft) vollständig, so dass eine Lücke entsteht.

Zur Veranschaulichung der Unterschiede verwenden wir einen Code:

console.log("Using `splice`:");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a.splice(0, 1);
console.log(a.length);            // 4
console.log(a[0]);                // "b"

console.log("Using `delete`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
delete a[0];
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // false
console.log(a.hasOwnProperty(0)); // false

console.log("Setting to `undefined`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a[0] = undefined;
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // true
console.log(a.hasOwnProperty(0)); // true

---

* (das ist ein Beitrag in meinem kleinen, blutarmen Blog)

Answer 2

Andere haben bereits richtig verglichen delete con splice .

Ein weiterer interessanter Vergleich ist delete gegen undefined : Ein gelöschtes Array-Element verbraucht weniger Speicher als eines, das nur auf undefined ;

Dieser Code wird zum Beispiel nicht beendet:

let y = 1;
let ary = [];
console.log("Fatal Error Coming Soon");
while (y < 4294967295)
{
    ary.push(y);
    ary[y] = undefined;
    y += 1;
}
console(ary.length);

Es erzeugt diesen Fehler:

FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory.

Wie Sie also sehen können undefined tatsächlich Heap-Speicher beansprucht.

Wenn Sie jedoch auch delete das ary-Element (anstatt es einfach auf undefined ), wird der Code langsam beendet:

let x = 1;
let ary = [];
console.log("This will take a while, but it will eventually finish successfully.");
while (x < 4294967295)
{
    ary.push(x);
    ary[x] = undefined;
    delete ary[x];
    x += 1;
}
console.log(`Success, array-length: ${ary.length}.`);

Dies sind extreme Beispiele, aber sie machen deutlich, dass delete die ich noch nirgends erwähnt gesehen habe.

Answer 3

function remove_array_value(array, value) {
    var index = array.indexOf(value);
    if (index >= 0) {
        array.splice(index, 1);
        reindex_array(array);
    }
}
function reindex_array(array) {
   var result = [];
    for (var key in array) {
        result.push(array[key]);
    }
    return result;
}

Beispiel:

var example_arr = ['apple', 'banana', 'lemon'];   // length = 3
remove_array_value(example_arr, 'banana');

Banane wird gelöscht und Array-Länge = 2

Answer 4

Derzeit gibt es zwei Möglichkeiten, dies zu tun

1. mit splice()

   arrayObject.splice(index, 1);

2. mit Löschen

   delete arrayObject[index];

Aber ich schlage immer vor, splice für Array-Objekte und delete für Objektattribute zu verwenden, da delete die Array-Länge nicht aktualisiert.

Answer 5

Wenn Sie ein kleines Array haben, können Sie filter :

myArray = ['a', 'b', 'c', 'd'];
myArray = myArray.filter(x => x !== 'b');