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

1334

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?

lYriCAlsSH
quelle
3
.spliceSchauen Sie sich für In-Schleifen diese Frage an: Aus Array in Javascript löschen .
Rob W
6
@andynormancx Ja, aber diese Antwort wurde erst am Tag danach veröffentlicht und hat so viele weitere Stimmen erhalten - ich würde sagen, es ist besser geschrieben, das muss es sein.
Camilo Martin
@andynormancx - Es scheint kein genaues Duplikat zu sein. Die Frage, die Sie verknüpft haben, lautet im Grunde, warum das Löschen eines Elements aus einem Array (wodurch es spärlich wird) seine Länge nicht verringert. Diese Frage fragt nach den Unterschieden zwischen deleteund Array.prototype.splice.
Chharvey
@chharvey stimmte zu, was noch wichtiger ist, wie kann diese Frage vor 9 Jahren gestellt worden sein? Ich fühle mich alt, wieder hier zu sein und es zu kommentieren
andynormancx

Antworten:

1693

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"]
Andy Hume
quelle
74
Tatsächlich delete funktioniert das Element entfernen, aber nicht indiziert das Array nicht oder aktualisieren , seine Länge (die bereits von den ehemaligen impliziert wird , da die Länge ist immer der höchste Index + 1).
Felix Kling
3
JSlint mag keine delete myArray[0]Syntax mit der Aufschrift " Erwartete einen Operator und sah stattdessen" Löschen ". " Die Verwendung splicewird empfohlen.
Auge
21
@Eye: Eigentlich beschwert sich JSLint nur über das Fehlen eines Semikolons in der vorherigen Zeile. Und man kann sich nicht wirklich gegenseitig empfehlen, da sie ganz andere Dinge tun…
Ry-
3
"Löschen setzt in diesem Fall nur das Element als undefiniert:" Nein, das ist völlig falsch. Es gibt einen grundlegenden Unterschied zwischen delete myArray[0]und myArray[0] = undefined. Im ersteren Fall wird die Eigenschaft vollständig aus dem Array-Objekt entfernt. Im zweiten Fall bleibt die Eigenschaft mit dem Wert erhalten undefined.
TJ Crowder
1
Zu Ihrer Information, die Chrome-Entwicklungstools zeigen das Schlüsselwort an, emptyanstatt undefineddie Unterscheidung zwischen einem tatsächlich gelöschten (oder nicht initialisierten) Array-Element und einem Element mit dem tatsächlichen Wert von zu verbessern undefined. Beachten Sie, dass ich damit meine, dass es nur als angezeigtempty wird und sich nicht auf einen reellen Wert bezieht, der aufgerufen wird empty(der nicht existiert).
Chharvey
340

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

Mohsen
quelle
4
+1 Für Array.remove (). Es ist jedoch nicht glücklich, Zeichenfolgenargumente übergeben zu bekommen (im Gegensatz zu den meisten Array-Methoden, z. B. [1,2,3].slice('1'); // =[2,3]), daher ist es sicherer, sie invar rest = this.slice(parseInt(to || from) + 1 || this.length);
Richard Inglis
1
@ Tomwrong, es gibt keine Threads in Javascript, und die Funktion wird ausgeführt this.push.apply(this, rest)und gibt dann den zurückgegebenen Wert zurück
Billy
59
Dies beantwortet die Frage überhaupt nicht.
Ry-
16
Warum nicht einfach splice () verwenden? Der Name dieser Funktion, die Parameternamen und die Ergebnisse sind nicht offensichtlich. Meine Empfehlung ist, nur Spleiß (Index, Länge) zu verwenden - (siehe Andy Humes Antwort)
auco
3
Die oben bereitgestellte Funktion funktioniert wie erläutert, erzeugt jedoch unerwünschte Nebenwirkungen, wenn das Array mit dem for(var i in array)Zyklus durchlaufen wird. Ich habe es entfernt und stattdessen Spleiß verwendet.
Alexykot
104

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]);
}
andynormancx
quelle
11
gutes Beispiel mit Ausnahme der Mehrdeutigkeit im zweiten Beispiel unter Verwendung von 1,1 - die erste 1 bezieht sich auf den Index im Array, um den Spleiß zu starten, die zweite 1 ist die Anzahl der zu entfernenden Elemente. Um 'c' aus dem ursprünglichen Array zu entfernen, verwenden SiemyArray.splice(2,1)
iancoleman
68

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"]
Troy Harvey
quelle
10

splice funktioniert mit numerischen Indizes.

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

Beispiel:

delete myArray['text1'];
Gopal
quelle
9
Wenn Sie "irgendeine andere Art von Indizes" sagen, sprechen Sie nicht mehr über Arrays, sondern über Objekte, worum es im OP geht.
Yi Jiang
2
@YiJiang: Arrays sind Objekte. Indizes sind Eigenschaften. Es gibt keinen Unterschied.
Bergi
9

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.
jtrick
quelle
Löschen ordnet die Array-Schlüssel nicht neu an, also: var arr = [1,2,3,4,5]; arr [3] löschen; für (var i = 0; i <= arr.length; i ++) console.log (arr [i]); wird unerwartete Ergebnisse zeigen.
Kristian Williams
Das ist wahr. Wenn Sie also kein undefiniertes Element an dieser Stelle belassen möchten, verwenden Sie NICHT Löschen für die Schlüssel eines Arrays! Ich habe diesen Kommentar ursprünglich hinzugefügt, um einen Verweis auf die korrekte Verwendung von Löschen aufzunehmen.
Jtrick
aber warum löscht wird unerwartetes Ergebnis werfen?
Alex
9

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

Ashish Yadav
quelle
8

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.

[...]

serv-inc
quelle
@downvoter: warum die downvote? Möchtest du es erklären oder nicht?
serv-inc
7

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.

med116
quelle
6

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)
},
Mike T.
quelle
Ich glaube der ++ Index; muss außerhalb des 'wenn' geschehen. Bearbeitung
vornehmen
6

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]

Zeeshan Saleem
quelle
Dies ist intuitiver als slicewenn Sie aus einem funktionalen Hintergrund stammen (wahrscheinlich jedoch weniger effizient).
Jethro
3

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
});
Asqan
quelle
Was ist mit einem Array mit Hunderten (wenn nicht Tausenden) von Datensätzen, von denen nur 3 entfernt werden müssen?
Joel Hernandez
guter Punkt. Ich benutze diese Methode für spärliche Arrays, deren Länge nicht mehr als 200 oder 300 beträgt und die sehr gut funktioniert. Ich denke jedoch, dass Bibliotheken wie Underline bevorzugt werden sollten, wenn Sie solche größeren Arrays verwalten müssen.
Asqan
1
Es scheint jedoch viel schöner als deleteoder slicefür mich.
Juneyoung Oh
3

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.

unter dem Code
quelle
2
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

Terry Lin
quelle
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)

TJ Crowder
quelle
2

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.

imal hasaranga perera
quelle
1

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 ...

Alireza
quelle
1

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.

Lonnie Best
quelle
1

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

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

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

Prashanth
quelle
1
Sollte jemand über diese Frage stolpern compact... keine Notwendigkeit für Lodash. Versuchen SiemyArray.filter(function(n){return n;})
dat
0

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);
...
Ricky Levi
quelle
0

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];
Srikrushna
quelle
0

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))
Idan Gozlan
quelle
0

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
Roland
quelle
-1
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'];

Eyad Farra
quelle
@ ChrisDennis warum? (Kein Sarkasmus oder Bosheit beabsichtigt, dies ist eine aufrichtige Frage)
Chris Bier
Abgesehen von der Tatsache, dass diese Antwort nicht die Frage des OP anspricht
Chris Bier