Was ist der Unterschied zwischen der Verwendung des deleteOperators für das Array-Element und der Verwendung der Array.spliceMethode ?

Zum Beispiel:

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

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

Warum überhaupt die Spleißmethode, wenn ich Array-Elemente wie mit Objekten löschen kann?

deletelöscht die Objekteigenschaft, indiziert das Array jedoch nicht neu und aktualisiert seine Länge nicht. Dies lässt es so aussehen, als ob es undefiniert ist:

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> delete myArray[0]
  true
> myArray[0]
  undefined

Beachten Sie, dass es nicht auf den Wert festgelegt ist undefined, sondern dass die Eigenschaft aus dem Array entfernt wird, sodass sie undefiniert erscheint . Die Chrome-Entwicklungstools machen diese Unterscheidung durch Drucken emptybeim Protokollieren des Arrays deutlich.

> myArray[0]
  undefined
> myArray
  [empty, "b", "c", "d"]

myArray.splice(start, deleteCount) Entfernt das Element tatsächlich, indiziert das Array neu und ändert seine Länge.

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> myArray.splice(0, 2)
  ["a", "b"]
> myArray
  ["c", "d"]

Array.remove () -Methode

John Resig , Schöpfer von jQuery, hat eine sehr praktische Array.removeMethode entwickelt, die ich in meinen Projekten immer verwende.

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};

und hier sind einige Beispiele, wie es verwendet werden könnte:

// Remove the second item from the array
array.remove(1);
// Remove the second-to-last item from the array
array.remove(-2);
// Remove the second and third items from the array
array.remove(1,2);
// Remove the last and second-to-last items from the array
array.remove(-2,-1);

Johns Website

Da beim Löschen nur das Objekt aus dem Element im Array entfernt wird, ändert sich die Länge des Arrays nicht. Splice entfernt das Objekt und verkürzt das Array.

Der folgende Code zeigt "a", "b", "undefiniert", "d" an.

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

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Während dies "a", "b", "d" anzeigt.

myArray = ['a', 'b', 'c', 'd']; myArray.splice(2,1);

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Ich bin auf diese Frage gestoßen, als ich versucht habe zu verstehen, wie jedes Vorkommen eines Elements aus einem Array entfernt werden kann. Hier ist ein Vergleich von spliceund deletezum Entfernen aller Elemente 'c'aus dem itemsArray.

var items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  items.splice(items.indexOf('c'), 1);
}

console.log(items); // ["a", "b", "d", "a", "b", "d"]

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

while (items.indexOf('c') !== -1) {
  delete items[items.indexOf('c')];
}

console.log(items); // ["a", "b", undefined, "d", "a", "b", undefined, "d"]
​

In Core JavaScript 1.5 Referenz> Operatoren> Spezielle Operatoren> Operator löschen :

Wenn Sie ein Array-Element löschen, wird die Array-Länge nicht beeinflusst. Wenn Sie beispielsweise eine [3] löschen, ist eine [4] immer noch eine [4] und eine [3] ist undefiniert. Dies gilt auch dann, wenn Sie das letzte Element des Arrays löschen (löschen Sie eine [a.length-1]).

splice funktioniert mit numerischen Indizes.

während deletegegen andere Art von Indizes verwendet werden ..

Beispiel:

delete myArray['text1'];

Erwähnenswert ist wahrscheinlich auch, dass Splice nur auf Arrays funktioniert. (Auf Objekteigenschaften kann nicht vertraut werden, um einer konsistenten Reihenfolge zu folgen.)

Um das Schlüssel-Wert-Paar aus einem Objekt zu entfernen, ist Löschen genau das, was Sie wollen:

delete myObj.propName;     // , or:
delete myObj["propName"];  // Equivalent.

Vs Splice löschen

wenn Sie ein Element aus einem Array löschen

var arr = [1,2,3,4]; delete arr[2]; //result [1, 2, 3:, 4]
console.log(arr)

wenn Sie spleißen

var arr = [1,2,3,4]; arr.splice(1,1); //result [1, 3, 4]
console.log(arr);

Beim Löschen wird das Element gelöscht , der Index bleibt jedoch leer

Im Falle eines Spleißelements wird der Index der Ruheelemente entsprechend reduziert

Wie bereits mehrfach erwähnt, splice()scheint die Verwendung perfekt zu passen. Dokumentation bei Mozilla:

Die splice()Methode ändert den Inhalt eines Arrays, indem vorhandene Elemente entfernt und / oder neue Elemente hinzugefügt werden.

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]

Syntax

array.splice(start)
array.splice(start, deleteCount)
array.splice(start, deleteCount, item1, item2, ...)

Parameter

Start

Index, an dem das Array geändert werden soll. Wenn die Länge des Arrays größer ist, wird der tatsächliche Startindex auf die Länge des Arrays festgelegt. Wenn negativ, beginnen so viele Elemente am Ende.

deleteCount

Eine Ganzzahl, die die Anzahl der zu entfernenden alten Array-Elemente angibt. Wenn deleteCount 0 ist, werden keine Elemente entfernt. In diesem Fall sollten Sie mindestens ein neues Element angeben. Wenn deleteCount größer ist als die Anzahl der Elemente, die ab dem Start im Array verbleiben, werden alle Elemente bis zum Ende des Arrays gelöscht.

Wenn deleteCount weggelassen wird, ist deleteCount gleich (arr.length - start).

item1, item2, ...

Die Elemente, die dem Array hinzugefügt werden sollen, beginnend mit dem Startindex. Wenn Sie keine Elemente angeben, splice()werden nur Elemente aus dem Array entfernt.

Rückgabewert

Ein Array mit den gelöschten Elementen. Wenn nur ein Element entfernt wird, wird ein Array mit einem Element zurückgegeben. Wenn keine Elemente entfernt werden, wird ein leeres Array zurückgegeben.

[...]

Löschen verhält sich wie eine nicht reale Situation, es entfernt nur das Element, aber die Array-Länge bleibt gleich:

Beispiel vom Knotenterminal:

> var arr = ["a","b","c","d"];
> delete arr[2]
true
> arr
[ 'a', 'b', , 'd', 'e' ]

Hier ist eine Funktion zum Entfernen eines Elements eines Arrays nach Index mithilfe von Slice (). Dabei wird arr als erstes Argument und der Index des Elements, das Sie löschen möchten, als zweites Argument verwendet. Wie Sie sehen können, wird das Mitglied des Arrays tatsächlich gelöscht und die Array-Länge um 1 verringert

function(arr,arrIndex){
    return arr.slice(0,arrIndex).concat(arr.slice(arrIndex + 1));
}

Die obige Funktion führt alle Mitglieder zum Index und alle Mitglieder nach dem Index, verkettet sie und gibt das Ergebnis zurück.

Hier ist ein Beispiel, in dem die obige Funktion als Knotenmodul verwendet wird. Es ist hilfreich, das Terminal zu sehen:

> var arr = ["a","b","c","d"]
> arr
[ 'a', 'b', 'c', 'd' ]
> arr.length
4 
> var arrayRemoveIndex = require("./lib/array_remove_index");
> var newArray = arrayRemoveIndex(arr,arr.indexOf('c'))
> newArray
[ 'a', 'b', 'd' ] // c ya later
> newArray.length
3

Bitte beachten Sie, dass dies nicht für ein Array mit Dupes funktioniert, da indexOf ("c") nur das erste Vorkommen erhält und nur das erste gefundene "c" herausspleißt und entfernt.

Wenn Sie ein großes Array iterieren und Elemente selektiv löschen möchten, ist es teuer, splice () für jedes Löschen aufzurufen, da splice () nachfolgende Elemente jedes Mal neu indizieren müsste. Da Arrays in Javascript assoziativ sind, wäre es effizienter, die einzelnen Elemente zu löschen und das Array anschließend neu zu indizieren.

Sie können dies tun, indem Sie ein neues Array erstellen. z.B

function reindexArray( array )
{
       var result = [];
        for( var key in array )
                result.push( array[key] );
        return result;
};

Ich glaube jedoch nicht, dass Sie die Schlüsselwerte im ursprünglichen Array ändern können, was effizienter wäre - es sieht so aus, als müssten Sie möglicherweise ein neues Array erstellen.

Beachten Sie, dass Sie nicht nach "undefinierten" Einträgen suchen müssen, da diese nicht vorhanden sind und die for-Schleife sie nicht zurückgibt. Es ist ein Artefakt des Array-Drucks, das sie als undefiniert anzeigt. Sie scheinen nicht im Gedächtnis zu existieren.

Es wäre schön, wenn Sie so etwas wie Slice () verwenden könnten, das schneller wäre, aber nicht neu indiziert. Kennt jemand einen besseren Weg?

Tatsächlich können Sie dies wahrscheinlich wie folgt tun, was in Bezug auf die Leistung wahrscheinlich effizienter ist:

reindexArray : function( array )
{
    var index = 0;                          // The index where the element should be
    for( var key in array )                 // Iterate the array
    {
        if( parseInt( key ) !== index )     // If the element is out of sequence
        {
            array[index] = array[key];      // Move it to the correct, earlier position in the array
            ++index;                        // Update the index
        }
    }

    array.splice( index );  // Remove any remaining elements (These will be duplicates of earlier items)
},

Sie können so etwas verwenden

var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';})); // [1,2,3,4,6]

Warum nicht einfach filtern? Ich denke, es ist der klarste Weg, die Arrays in js zu betrachten.

myArray = myArray.filter(function(item){
    return item.anProperty != whoShouldBeDeleted
});

Der Unterschied kann durch Protokollieren der Länge jedes Arrays nach Anwendung des deleteOperators und der splice()Methode festgestellt werden . Zum Beispiel:

Operator löschen

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];

console.log(trees); // ["redwood", "bay", "cedar", empty, "maple"]
console.log(trees.length); // 5

Der deleteOperator entfernt das Element aus dem Array, aber der "Platzhalter" des Elements ist noch vorhanden. oakwurde entfernt, benötigt aber noch Platz im Array. Aus diesem Grund bleibt die Länge des Arrays 5.

splice () Methode

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees.splice(3,1);

console.log(trees); // ["redwood", "bay", "cedar", "maple"]
console.log(trees.length); // 4

Die splice()Methode entfernt den Zielwert und den "Platzhalter" ebenfalls vollständig . oakwurde entfernt sowie der Platz, den es im Array belegt hat. Die Länge des Arrays beträgt jetzt 4.

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

Es sind verschiedene Dinge, die unterschiedliche Zwecke haben.

spliceist Array-spezifisch und entfernt beim Löschen Einträge aus dem Array und verschiebt alle vorherigen Einträge nach oben, um die Lücke zu füllen. (Es kann auch verwendet werden, um Einträge oder beides gleichzeitig einzufügen.) spliceÄndert lengthdas Array (vorausgesetzt, es handelt sich nicht um einen No-Op-Aufruf :) theArray.splice(x, 0).

deleteist nicht Array-spezifisch; Es wurde für die Verwendung in Objekten entwickelt: Es entfernt eine Eigenschaft (Schlüssel / Wert-Paar) aus dem Objekt, für das Sie es verwenden. Dies gilt nur für Arrays, da Standard-Arrays (z. B. nicht typisierte Arrays) in JavaScript überhaupt keine Arrays sind *, sondern Objekte mit besonderer Behandlung für bestimmte Eigenschaften, z. B. solche, deren Namen "Array-Indizes" sind definiert als Stringnamen "... deren numerischer Wert iim Bereich liegt +0 ≤ i < 2^32-1") und length. Wenn Sie deleteeinen Array-Eintrag entfernen, wird lediglich der Eintrag entfernt. Es werden keine weiteren Einträge verschoben, um die Lücke zu füllen, und so wird das Array "spärlich" (einige Einträge fehlen vollständig). Es hat keine Auswirkung auf length.

In einigen aktuellen Antworten auf diese Frage wird fälschlicherweise angegeben, dass mit delete"den Eintrag auf undefined" gesetzt wird. Das stimmt nicht Es entfernt den Eintrag (die Eigenschaft) vollständig und hinterlässt eine Lücke.

Verwenden wir einen Code, um die Unterschiede zu veranschaulichen:

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 anämischen kleinen Blog)

Derzeit gibt es zwei Möglichkeiten, dies zu tun

1. mit splice ()

   arrayObject.splice(index, 1);

2. mit löschen

   delete arrayObject[index];

Ich empfehle jedoch immer, Spleiß für Array-Objekte und Löschen für Objektattribute zu verwenden, da durch Löschen die Array-Länge nicht aktualisiert wird.

OK, stellen Sie sich vor, wir haben dieses Array unten:

const arr = [1, 2, 3, 4, 5];

Lassen Sie uns zuerst löschen:

delete arr[1];

und das ist das Ergebnis:

[1, empty, 3, 4, 5];

leeren! und lass es uns bekommen:

arr[1]; //undefined

Bedeutet also, dass nur der Wert gelöscht wurde und jetzt undefiniert ist. Die Länge ist also gleich und es wird auch true zurückgegeben ...

Lassen Sie uns unser Array zurücksetzen und diesmal mit Spleiß ausführen:

arr.splice(1, 1);

und diesmal ist das Ergebnis:

[1, 3, 4, 5];

Wie Sie sehen, hat sich die Array-Länge geändert und arr[1]beträgt jetzt 3 ...

Dies gibt auch das gelöschte Element in einem Array zurück, das [3]in diesem Fall ...

Andere haben bereits richtig verglichen deletemit splice.

Ein weiterer interessanter Vergleich ist deleteversus undefined: Ein gelöschtes Array-Element benötigt weniger Speicher als eines, das gerade eingestellt ist undefined.

Dieser Code wird beispielsweise 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 sehen, undefinednimmt der Heap-Speicher also tatsächlich Platz.

Wenn Sie jedoch auch deletedas ary-Element verwenden (anstatt es nur auf zu setzen 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 weisen darauf hin, deletedass ich nirgendwo jemanden erwähnt habe.

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

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

Der einfachste Weg ist wahrscheinlich

var myArray = ['a', 'b', 'c', 'd'];
delete myArray[1]; // ['a', undefined, 'c', 'd']. Then use lodash compact method to remove false, null, 0, "", undefined and NaN
myArray = _.compact(myArray); ['a', 'c', 'd'];

Hoffe das hilft. Referenz: https://lodash.com/docs#compact

Für diejenigen, die Lodash verwenden möchten, können Sie verwenden: myArray = _.without(myArray, itemToRemove)

Oder wie ich es in Angular2 benutze

import { without } from 'lodash';
...
myArray = without(myArray, itemToRemove);
...

delete : delete löscht die Objekteigenschaft, indiziert das Array jedoch nicht neu und aktualisiert seine Länge nicht. Dies lässt es so aussehen, als ob es undefiniert ist:

Spleiß : Entfernt das Element, indiziert das Array neu und ändert seine Länge.

Element vom letzten löschen

arrName.pop();

Element zuerst löschen

arrName.shift();

Aus der Mitte löschen

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

Löschen Sie ein Element vom letzten

arrName.splice(-1);

Löschen Sie mit der Array-Indexnummer

 delete arrName[1];

Wenn sich das gewünschte zu löschende Element in der Mitte befindet (sagen wir, wir möchten 'c' löschen, dessen Index 1 ist), können Sie Folgendes verwenden:

var arr = ['a','b','c'];
var indexToDelete = 1;
var newArray = arr.slice(0,indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

IndexOfakzeptiert auch einen Referenztyp. Angenommen, das folgende Szenario:

var arr = [{item: 1}, {item: 2}, {item: 3}];
var found = find(2, 3); //pseudo code: will return [{item: 2}, {item:3}]
var l = found.length;

while(l--) {
   var index = arr.indexOf(found[l])
      arr.splice(index, 1);
   }
   
console.log(arr.length); //1

Anders:

var item2 = findUnique(2); //will return {item: 2}
var l = arr.length;
var found = false;
  while(!found && l--) {
  found = arr[l] === item2;
}

console.log(l, arr[l]);// l is index, arr[l] is the item you look for

function deleteFromArray(array, indexToDelete){
  var remain = new Array();
  for(var i in array){
    if(array[i] == indexToDelete){
      continue;
    }
    remain.push(array[i]);
  }
  return remain;
}

myArray = ['a', 'b', 'c', 'd'];
deleteFromArray(myArray , 0);

// Ergebnis: myArray = ['b', 'c', 'd'];