Array-Elemente in JavaScript löschen – löschen vs. spleißen

https://stackoverflow.com/questions/500606

20-08-2019
|

Frage

Was ist der Unterschied zwischen der Verwendung Die delete Operator auf dem Array-Element im Gegensatz zur Verwendung Die Array.splice Methode?

Zum Beispiel:

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

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

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

Lösung

delete wird die Objekteigenschaft löschen, sondern wird das Array nicht indizieren oder seine Länge aktualisieren. Dies macht es scheint, als ob es ist nicht definiert:

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

Beachten Sie, dass es nicht in der Tat auf den Wert undefined gesetzt, sondern die Eigenschaft aus dem Array entfernt wird, so dass es erscheint nicht definiert. Die Chrome-Entwickler-Tools machen diese Unterscheidung klar durch empty Druck, wenn das Array anzumelden.

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

myArray.splice(start, deleteCount) eigentlich das Element entfernt, indiziert das Array und ändert seine Länge.

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

Andere Tipps

Array.remove () Methode

John Resig , der Schöpfer von jQuery eine sehr praktische Array.remove Methode erstellt, dass ich es immer in meinen Projekten verwenden.

// 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 einige Beispiele dafür, 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);

John Webseite

Da nur löschen Sie das Objekt aus dem Element in dem Array entfernt, wird die Länge des Arrays ändern. Splice entfernt das Objekt und verkürzt die Array.

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

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

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

Während dies zeigt "a", "b", "d"

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

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

ich auf diese Frage gestolpert bei dem Versuch, zu verstehen, wie jedes Vorkommen eines Elements aus einem Array zu entfernen. Hier ist ein Vergleich von splice und delete für jeden 'c' vom items Array zu entfernen.

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

Core-JavaScript 1.5 Reference> Operatoren> Besondere Operatoren> löschen Operator

Wenn Sie ein Array-Element löschen, die Arraylänge ist nicht betroffen. Zum Wenn Sie beispielsweise ein [3] löschen, a [4] noch ein [4] und a [3] ist nicht definiert. Diese hält, auch wenn Sie das letzte löschen Element des Arrays (löschen a [a.length-1]).

splice wird mit numerischen Indizes arbeiten.

während delete kann gegen andere Art von Indizes verwendet werden ..

Beispiel:

delete myArray['text1'];

Es ist wahrscheinlich auch erwähnenswert, dass Spleiß nur auf Arrays funktioniert. (Objekteigenschaften können nicht geltend gemacht werden, um eine konsistente, um zu folgen.)

Um das Schlüssel-Wert-Paar von einem Objekt zu entfernen, löschen ist eigentlich das, was Sie wollen:

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

Wie viele Male oben erwähnt, splice() Verwendung scheint wie eine perfekte Passform. Dokumentation bei Mozilla:

splice() Verfahren ändert den Inhalt eines Felds von vorhandenen Elemente zu entfernen und / oder das Hinzufügen von neuen Elementen.
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

starten

Index, bei dem zum Starten des Array ändern. Wenn sie größer als die Länge des Arrays, wird tatsächlicher Anfangsindex auf die Länge des Arrays eingestellt werden. Wenn negativ, beginnt, dass viele Elemente vom Ende.

deleteCount

Eine Ganzzahl die Anzahl der alten Feldelemente angibt zu entfernen. 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 in dem Array links am Anfang beginnen, dann alle Elemente bis zum Ende des Arrays wird gelöscht.

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

item1, item2, ...

Die Elemente in das Array, beginnend am Anfang Index hinzuzufügen. Wenn Sie keine Elemente angeben, wird splice() nur Elemente aus dem Array entfernt werden.

Rückgabewert

Ein Array die gelöschten Elemente enthalten. Wenn nur ein Element entfernt wird, ist ein Array von einem Element zurückgegeben. Wenn keine Elemente entfernt werden, wird ein leeres Array zurückgegeben wird.

[...]

löschen Vs Spleiß

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 splice

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

bei Löschen Element wird gelöscht , aber der Index bleibt leer

, während im Fall von splice Elemente gelöscht und der index Ruheelemente verringert dementsprechend

Löschen verhält sich wie eine nicht Situation der realen Welt, es nur entfernt das Element, aber die Feldlänge bleibt gleich:

Beispiel von dem Knoten terminal:

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

Hier ist eine Funktion, ein Element eines Arrays von Index zu entfernen, mit slice () , den arr als erstes arg nimmt, und der Index des Elements möchten Sie als löschen zweites Argument. Wie Sie sehen können, löscht er tatsächlich das Element des Arrays, und die Array-Länge von 1

reduzieren

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

Was oben ist die Funktion ist es, alle Mitglieder nehmen bis zu dem Index, und alle Mitglieder nach dem Index und verkettet sie zusammen und gibt das Ergebnis aus.

Hier ist ein Beispiel ist die Funktion oben als Knotenmodul verwenden, das Terminal zu sehen, nützlich sein:

> 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 ein Array nicht mit Duplikaten in ihm funktionieren wird, weil indexOf ( „c“) wird nur das erste Vorkommen erhalten, und nur Spleiß aus und entfernen Sie die ersten „c“ es findet.

Wenn Sie eine große Array zu durchlaufen wollen und selektiv Elemente zu löschen, wäre es teuer splice () aufzurufen, für jeden löschen, da splice () haben würde jedes Mal nachfolgenden Elemente neu indizieren. Da Arrays in Javascript assoziativ sind, wäre es effizienter sein, die einzelnen Elemente dann wieder Index das Array anschließend zu löschen.

Sie können es tun, indem Sie ein neues Array zu bauen. z

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

Aber ich glaube nicht, dass Sie die Schlüsselwerte im ursprünglichen Array ändern können, die effizient wäre -. Es sieht aus wie Sie ein neues Array erstellen können müssen

Beachten Sie, dass Sie benötigen, um Einträge nicht überprüfen Sie die „undefiniert“, da sie nicht wirklich existieren und die for-Schleife sie nicht zurück. Es ist ein Artefakt des Arrays Druck, der sie als undefiniert anzeigt. Sie erscheinen nicht im Speicher vorhanden ist.

Es wäre schön, wenn Sie so etwas wie Scheibe verwenden könnten (), die schneller sein würde, aber es ist nicht neu indizieren. Wer weiß, einen besseren Weg?

Eigentlich kann man tun, um es in Position wahrscheinlich wie folgt was wahrscheinlich effizienter, leistungsmäßig:

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 so etwas wie diese verwenden können,

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 die klare Art und Weise ist die Arrays in js.

zu betrachten

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

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 Feldlänge = 2

Sie sind verschiedene Dinge, die unterschiedliche Zwecke haben.

splice ist Array-spezifische und, wenn zum Löschen verwendet wird, entfernt Einträge aus dem Feld und verschiebt alle vorherigen Einträge, um die Lücke zu füllen. (. Es kann auch Einträge verwendet werden, um einzufügen, oder beides zugleich) splice die length des Arrays ändern (vorausgesetzt, es ist kein No-Op-Aufruf: theArray.splice(x, 0)).

delete ist nicht Array-spezifisch; es ist für den Einsatz auf Objekte entworfen: Es entfernt eine Eigenschaft (Schlüssel / Wert-Paar) aus dem Objekt, das Sie es verwenden, auf. Sie gilt nur für Arrays, da Standard (zB nicht typisierte) Arrays in JavaScript sind nicht wirklich alle * Arrays an, sie sind Objekte mit Sonderbehandlung für bestimmte Eigenschaften, wie diejenigen, deren Namen „Array-Indizes“ sind (die definiert als String Name" ... Zahlenwert, das i im Bereich +0 ≤ i < 2^32-1 ist“ ) und length. Wenn Sie delete verwenden, um einen Array-Eintrag zu entfernen, setzt alles daran, den Eintrag entfernen; es keine anderen Einträge verschieben Sie es Verfolgung um die Lücke zu füllen, und so das Array wird „spärlich“ (hat einige Einträge fehlen ganz). Es hat keinen Einfluss auf length.

Ein paar der aktuellen Antworten auf diese Frage falsch fest, dass delete mit „setzt den Eintrag undefined“. Das ist nicht richtig. Es entfernt der Eintrag (Eigentum) vollständig, eine Lücke zu verlassen.

Lassen Sie uns einige Code verwenden, um die Unterschiede zu verdeutlichen:

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 auf meinem anämisch kleines Blog)

Zur Zeit gibt es zwei Möglichkeiten, dies zu tun

mit splice ()

arrayObject.splice(index, 1);
löschen mit

delete arrayObject[index];

Aber ich schlage immer Spleiß zu verwenden, für die Array-Objekte, und löschen Sie für Objektattribute, weil nicht gelöscht Arraylänge aktualisieren.

Der Unterschied kann durch die Protokollierung der Länge jedes Arrays gesehen werden, nachdem der Operator delete und splice() Verfahren angewendet werden. Zum Beispiel:

löschen Operator

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

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

Der delete Operator entfernt das Element aus dem Array, aber die „Platzhalter“ des Elements ist noch vorhanden. oak wurde entfernt, aber es dauert noch Platz in der Anordnung. Aus diesem Grunde 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

Das splice() Verfahren vollständig entfernt den Zielwert und die „Platzhalter“ als auch. oak wurde sowie dem Raum entfernt es verwendet in der Matrix zu besetzen. Die Länge des Arrays ist jetzt 4.

OK, stellen Sie sich vor, wir hätten 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];

leer! und lass es uns wissen:

arr[1]; //undefined

Das bedeutet also, dass nur der Wert gelöscht wird und es ist nicht definiert Jetzt ist die Länge gleich und es wird auch zurückkehren WAHR...

Lassen Sie uns unser Array zurücksetzen und es dieses Mal mit Splice tun:

arr.splice(1, 1);

und das ist dieses Mal das Ergebnis:

[1, 3, 4, 5];

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

Außerdem wird dadurch das gelöschte Element in einem Array zurückgegeben [3] in diesem Fall...

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 verwenden möchte Lodash verwenden können: myArray = _.without(myArray, itemToRemove)

Oder wie ich in Angular2

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

Löschen : Zum Löschen wird die Objekteigenschaft löschen, aber nicht indizieren   das Array oder seine Länge aktualisieren. Dies macht es scheint, als ob es   undefined:

splice : Tatsächlich entfernt das Element, indiziert das Array und Änderungen   seine Länge.

Löschen Element von den letzten

arrName.pop();

Löschen Element aus dem ersten

arrName.shift();

von Mitte Löschen

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

Ex: arrName.splice(1,1);

Löschen eines Elements aus dem letzten

arrName.splice(-1);

Löschen von Array-Index-Nummer mit

 delete arrName[1];

Wenn das gewünschte Element in der Mitte zu löschen (sagen wir ‚c‘ löschen, die ihr Index 1), können Sie:

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

IndexOf akzeptiert auch einen Referenztyp. Angenommen, das folgende Szenario vor:

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

Im Unterschied:

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

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow