Javascript – Entfernen – JS-Arrays. Wie entferne ich ein bestimmtes JavaScript-Array-Element? Element aus Array-Javascript entfernen

Ich habe nur einige der Methoden zum Arbeiten mit Arrays beschrieben.

Hier werden wir über das Hinzufügen und Entfernen von Array-Elementen sprechen. Informationen zum Umdrehen und Sortieren eines Arrays sowie zum Teilen, Ersetzen und Kombinieren von Arrays.

Sie können die Längeneigenschaft verwenden, um dem Array neue Elemente hinzuzufügen:

Var myArray = ["Apple", "Microsoft", "Google", "Facebook"]; myArray = "Yahoo!"; console.log(myArray); // [„Apple“, „Microsoft“, „Google“, „Facebook“, „Yahoo!“]

Das wird funktionieren, weil... Array-Elemente werden beginnend bei Null nummeriert und die Länge beträgt eins mehr. Länge entspricht immer index + 1 , daher ist es sehr einfach, ein neues Element am Ende des Arrays hinzuzufügen. Seltsamerweise können Sie ein Element an einer Position hinzufügen, die viel größer ist als die Länge des Arrays selbst:

Var myArray = ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards"]; myArray = "Lindsey Buckingham"; console.log(myArray); // ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards", undefiniert × 95, "Lindsey Buckingham"] console.log(myArray.length); // 100

Wie in den Kommentaren gezeigt, werden dadurch 95 leere Slots und das Element „Lindsey Buckingham“ am Ende des Arrays hinzugefügt. Danach erhalten wir eine Länge von 100. Eine andere Möglichkeit, dem Array ein neues Element hinzuzufügen, ist die Verwendung der push()-Methode:

Var myArray = ["Paul McCartney", "John Lennon", "George Harrison"]; myArray.push("Ringo Starr", "George Martin"); console.log(myArray); // [„Paul McCartney“, „John Lennon“, „George Harrison“, „Ringo Starr“, „George Martin“]

Die Methode push() gibt immer die neue Array-Länge zurück (in unserem Fall 5). Sie können ein Element mit splice() hinzufügen:

Var myArray = ["acorn", "beech", "mongongo", "macadamia"]; myArray.splice(2, 0, "Cashew"); // fügt „Cashew“ zu Index 2 hinzu console.log(myArray); // [„Eichel“, „Buche“, „Cashew“, „Mongongo“, „Macadamia“]

Wenn das zweite Argument 0 ist, bedeutet dies, dass kein Element entfernt wird und daher alle nachfolgenden Argumente dem Array an der im ersten Argument angegebenen Position hinzugefügt werden.

Das Entfernen eines Elements ist etwas schwieriger als das Hinzufügen. Um ein Element vom Ende eines Arrays zu entfernen, können Sie pop() verwenden:

Var myArray = ["7-up", "Sprite", "Ginger Ale", "Lemonade"]; myArray.pop(); console.log(myArray); // ["7-up", "Sprite", "Ginger Ale"]

Die Methode pop() entfernt immer das letzte Element im Array und gibt es zurück.

Sie können auch die splice()-Methode verwenden:

Var myArray = ["Cassava", "Muskatnuss", "Lupine", "Rhabarber"]; myArray.splice(2, 1); // Element mit Index 2 entfernen console.log(myArray); // ["Maniok", "Muskatnuss", "Rhabarber"]

Im Gegensatz zur splice()-Methode, die zum Hinzufügen von Elementen verwendet wird, ist hier das zweite Argument 1, was besagt, dass wir das Element mit Index 2 (oder dem dritten in Folge) entfernen möchten. In diesem Fall wurde das Element „Lupine“ entfernt.

Sie können ein Array-Element mit dem Löschoperator löschen:

Var myArray = ["Byte Bandit", "Eliza", "Jeefo", "Michelangelo"]; console.log(myArray.length); // 4 myArray löschen; // Eliza löschen console.log(myArray.length); // 4 console.log(myArray); // ["Byte Bandit", undefiniert × 1, "Jeefo", "Michelangelo"]

Erste wichtiger Hinweis: delete() ändert die Länge des Arrays nicht, nachdem ein Element gelöscht wurde (auch wenn es das letzte Element im Array war). Zweitens: delete() ändert den Wert des zu löschenden Elements in undefiniert, sodass beim Aufruf myArray = undefiniert ist.

Eine gute Möglichkeit, ein Element aus einem Array zu entfernen, ist die Verwendung von John Resigs Array.remove. Nachfolgend finden Sie ein Anwendungsbeispiel von seiner Seite:

// Array Remove – Von John Resig (MIT-Lizenz) Array.prototype.remove = function(from, to) ( var rest = this.slice((to || from) + 1 || this.length); this.length = von< 0 ? this.length + from: from; return this.push.apply(this, rest); }; // Удаление 2 элемента из массива array.remove(1); // Удаление 2-ого элемента с конца массива array.remove(-2); // Удаление второго и третьего элемента array.remove(1,2); // Удаление последнего и предпоследнего элемента array.remove(-2,-1);

Vielleicht möchten Sie sich die Lösung von Viral Patel, eine der Funktionen in Underscore.js oder grep() von jQuery ansehen.

Darüber hinaus verfügt JavaScript über eine Shift()-Methode, die das erste Element in einem Array entfernt und seinen Wert zurückgibt. Schauen wir uns den Code an:

Var myArray = ["Matt Kramer", "Jason Bieler", "Tom Defile", "Phil Varone"]; console.log(myArray.length); // 4 var firstItem = myArray.shift(); console.log(firstItem); // Matt Kramer console.log(myArray.length); // 3 console.log(myArray); // [„Jason Bieler“, „Tom Defile“, „Phil Varone“]

Mit der Methode „shift()“ haben wir das Element entfernt, seinen Wert jedoch in unserer Variable „firstItem“ gespeichert. Die Array-Länge wurde von 4 auf 3 geändert.

Diese Methode kann in Verbindung mit der push()-Methode nützlich sein. Wenn wir sie zusammen verwenden, können wir Elemente in einem Array effizient in die Warteschlange stellen. Wir behalten die Länge des Arrays bei, indem wir ein Element am Anfang entfernen und am Ende ein neues hinzufügen.

Umgekehrt können wir die Methode unshift() verwenden, um ein Element am Anfang des Arrays hinzuzufügen:

Var myArray = ["apito", "kastagnetten", "maraca"]; console.log(myArray.length); // 3 myArray.unshift("chime bar", "tan-tan"); console.log(myArray.length); // 5 console.log(myArray); // ["Chime Bar", "tan-tan", "apito", "castanets", "maraca"]

Durch die Verwendung der unshift()-Methode mit der pop()-Methode können Sie Warteschlangen erstellen Rückseite, indem Elemente am Anfang hinzugefügt und am Ende des Arrays entfernt werden.

Um die Elemente in einem Array umzukehren, können wir reverse() verwenden:

Var myArray = ["countdown", "final", "the"]; console.log(myArray); // ["countdown", "final", "the"] myArray = myArray.reverse(); console.log(myArray); // ["Der finale Countdown"]

Mit der Methode sort() ist es möglich, Array-Elemente in alphabetischer Reihenfolge zu sortieren:

Var myArray = ["xylophones", "zebras", "juggernauts", "avocados"]; console.log(myArray); // ["Xylophone", "Zebras", "Juggernauts", "Avocados"] myArray = myArray.sort(); console.log(myArray); // ["Avocados", "Juggernauts", "Xylophone", "Zebras"]

Aber mit Zahlen funktioniert das nicht.

Var myArray = ; console.log(myArray); // myArray = myArray.sort(); console.log(myArray); //

Wenn Sie Zahlen sortieren müssen, können Sie den folgenden Code verwenden:

Funktion vergleichenNumbers(a, b) ( return a - b; ) var myArray = ; console.log(myArray); // myArray = myArray.sort(compareNumbers); console.log(myArray); //

Wie oben gezeigt, wird das Array mit den Zahlen korrekt sortiert, wenn eine einfache Funktion in sort() eingefügt wird.

Wir können zwei oder mehr Arrays kombinieren und 1 Array erhalten, das die Elemente der verbundenen Arrays enthält. Dazu verwenden wir die Methode concat():

Var myArray = ["Jay Ferguson", "Andrew Scott"]; var myArray2 = ["Chris Murphy", "Patrick Pentland"]; var myNewArray = myArray.concat(myArray2); console.log(myNewArray); // [„Jay Ferguson“, „Andrew Scott“, „Chris Murphy“, „Patrick Pentland“]

Var myArray = ["Jay Ferguson", "Andrew Scott"]; var myNewArray = myArray.concat("Chris Murphy", "Patrick Pentland"); console.log(myNewArray); // [„Jay Ferguson“, „Andrew Scott“, „Chris Murphy“, „Patrick Pentland“]

Mit der Funktion „slice()“ können wir aus einem vorhandenen Array ein neues Array erstellen, das ein oder mehrere Elemente enthält:

Var myArray = ["Vocals", "Bass", "Guitar", "Drums", "Apples", "Oranges"]; var myNewArray = myArray.slice(4); console.log(myNewArray); // ["Äpfel", "Orangen"]

Die Methode „slice()“ benötigt 1 oder 2 Argumente. Wenn 1 Argument (Index) übergeben wird, wird ausgehend von diesem Index ein neues Array aus allen Elementen des alten erstellt. Wenn 2 Argumente übergeben werden, wird ein neues Array aus den Elementen erstellt, beginnend beim ersten Argument und bis zu dem Element mit dem im zweiten Parameter übergebenen Index, das letzte nicht eingeschlossen. Um es klarer zu machen, schauen wir uns den folgenden Code an:

Var myArray = ["Vocals", "Bass", "Guitar", "Drums", "Apples", "Oranges"]; var myNewArray = myArray.slice(0, 4); console.log(myNewArray); // [„Gesang“, „Bass“, „Gitarre“, „Schlagzeug“]

Wir verwenden splice(), um Elemente aus einem Array zu entfernen, wir können aber auch ein Element im Array durch neue Elemente ersetzen:

Var myArray = ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Matt Sharp"]; myArray.splice(3, 1, „Scott Shriner“); // 1 Element durch Index 3 ersetzen console.log(myArray); // [„Rivers Cuomo“, „Patrick Wilson“, „Brian Bell“, „Scott Shriner“]

Die splice()-Methode gibt immer ein Array zurück, das die entfernten Elemente enthält. Zeile 2 gibt 1 Element „Brian Bell“ zurück.

In diesen Artikeln wurden Methoden zum Arbeiten mit Arrays in JavaScript beschrieben. Es gibt einige zusätzliche Elemente, die Sie auf MDN ansehen können und die ich in diesem Beitrag nicht aufgeführt habe. Sie funktionieren nur in IE9+ und sind daher möglicherweise nicht nützlich.

Gibt es noch etwas hinzuzufügen? Oder kennen Sie eine interessante Bibliothek, die bei der Verwaltung von Arrays hilft? Bitte kommentieren!

Es gibt mehrere Methoden zum Entfernen eines Array-Elements in JavaScript. Dazu gehören die Pop- und Shift-Methoden. Die Pop-Methode entfernt das erste Element aus dem angegebenen Array. Die Shift-Methode entfernt das letzte Element aus dem angegebenen Array.

Sie können die Array-Länge auf 0 setzen, wenn Sie alle Elemente aus dem angegebenen Array entfernen möchten. Aber was müssen Sie tun, um ein bestimmtes Element zu entfernen?

Zum Beispiel:

Array_name.splice(index);

Array_name.delete

Sie können die Spleißmethode verwenden. Es gibt ein neues Array entfernter Elemente zurück. Und das ursprüngliche Array enthält die restlichen Elemente.

Sehen Sie sich die Demo unten an, um zu erfahren, wie Sie die JavaScript-Splice-Methode und andere Möglichkeiten zum Entfernen bestimmter Elemente verwenden.

Diese Demo erstellt ein Array von Zahlen. Zunächst werden dem Array fünf Elemente hinzugefügt. Anschließend wird das dritte Element mit der Spleißmethode entfernt. Auf die gleiche Weise können Sie in JavaScript das erste Element eines Arrays entfernen.

Numerische Array-Elemente werden vor und nach der Verwendung angezeigt JavaScript-Methode so zusammenfügen:

JavaScript-Code mit Splice-Methode:

"; für (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "
"; ) document.getElementById("p1").innerHTML = the_arr_before_after; Arrretrun = Arr_Numbers.splice(2,1); var the_arr_before_after = "Array-Elemente nach der Spleißmethode:
"; für (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "

Sie werden feststellen, dass ich zwei Parameter für JavaScript verwendet habe, um ein Array-Element zu entfernen. Der erste gibt den Index des zu entfernenden Elements an. Die zweite ist, wie viele Elemente nach dem angegebenen Schlüssel entfernt werden müssen.

Die folgende Demo zeigt einen Fall, in dem wir den zweiten Parameter verwenden.

Verwendung des gleichen Codes, jedoch ohne den zweiten Parameter in der Splice-Methode:

Arr_Numbers.splice(2);

Code und Ergebnis:

Online-Demo und Code ansehen

Wie Sie sehen, wurden auch alle Elemente vor der angegebenen Indexnummer entfernt. Darüber hinaus gibt die Splice-Methode ein Array entfernter Elemente zurück.

JavaScript-Code:

var Arr_Numbers = ; var i; var the_arr_before_after = „Das ursprüngliche Array:
"; für (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "
"; ) document.getElementById("p1").innerHTML = the_arr_before_after; Arrretrun = Arr_Numbers.splice(2); var the_arr_before_after = "Array-Elemente nach der Spleißmethode:
"; für (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "
"; ) document.getElementById("p2").innerHTML = the_arr_before_after; //Entfernte Array-Elemente im zurückgegebenen Array var the_arr_before_after = "Die entfernten Array-Elemente:
"; für (i=0; i< Arrretrun.length; i++){ the_arr_before_after += Arrretrun[i] + "
"; ) document.getElementById("p3").innerHTML = the_arr_before_after;

Sie können die Löschfunktion auch verwenden, um ein Array-Element in JavaScript zu löschen. Aber es spart leeren Platz, und wenn Sie dieses Array nach Verwendung der Funktion zurückgeben, wird das entfernte Element als undefiniert gerendert.

Schauen wir uns eine Demo an, die die Löschfunktion verwendet:

Online-Demo und Code ansehen

JavaScript-Code:

var Arr_Strings = ["The","JavaScript","Array","Totorial"]; var i; var the_arr_before_after = „Die ursprünglichen String-Array-Elemente:

"; für (i=0; i< Arr_Strings.length; i++){ the_arr_before_after += Arr_Strings[i] + "
"; ) document.getElementById("p1").innerHTML = the_arr_before_after; //Mit der Löschfunktion delete Arr_Strings; var the_arr_before_after = "Array-Elemente nach der Spleißmethode:

"; für (i=0; i< Arr_Strings.length; i++){ the_arr_before_after += Arr_Strings[i] + "
"; ) document.getElementById("p2").innerHTML = the_arr_before_after;

Sie können sehen, dass das dritte Element undefiniert angezeigt wird, nachdem es mit der Löschfunktion gelöscht wurde.

Gibt es eine Möglichkeit, ein Element aus einem JavaScript-Array zu entfernen?

Gegeben ein Array:

Var ary = ["drei", "sieben", "elf"];

Ich würde gerne etwas tun wie:

RemoveItem("seven", ary);

Ich habe mir splice() angesehen, aber dadurch wird nur die Positionsnummer entfernt, während ich etwas benötige, um das Element anhand seines Werts zu entfernen.

// bearbeitet, danke an MarcoCI für den Rat

Versuch es:

Funktion wantDelete(item, arr)( for (var i=0;i !(comment.Id === commentId));

Hier ist eine Version, die die inArray-Funktion von jQuery verwendet:

Var index = $.inArray(item, array); if (index != -1) ( array.splice(index, 1); )

Sie können dies mit der Lodash-Funktion _.remove erreichen.

var array = ["drei", "sieben", "elf"]; var evens = _.remove(array, function(e) ( return e !== "seven"; )); console.log(evens);

Const _ = require("lodash"); _.without(, 2); // ->

Ich verstehe wirklich nicht, warum das nicht mit gelöst werden kann

Arr = arr.filter(value => value !== "seven");

Oder vielleicht möchten Sie Vanilla JS verwenden

Arr = arr.filter(function(value) ( ​​​​return value !== "seven" ));

Eine weitere Variante:

If (!Array.prototype.removeArr) ( Array.prototype.removeArr = function(arr) ( if(!Array.isArray(arr)) arr=;//Seien wir nett zu Leuten, die einen Nicht-Array-Wert eingeben hier.. das könnte ich sein! var that = this; if(arr.length)( var i=0; while(i-1)( that.splice(i,1); )else i++; ) ) return that; ) )

Dies ist wiederum indexOf() innerhalb der Schleife, allerdings unter der Annahme, dass das zu löschende Array im Verhältnis zum zu löschenden Array klein ist; Jede Löschung verkürzt die while-Schleife.

Dadurch können Sie Folgendes tun:

Var ary = ["drei", "sieben", "elf"]; var aryWithoutSeven = ary.filter(function(value) ( ​​​​return value != "seven" )); console.log(aryWithoutSeven); // gibt ["drei", "elf"] zurück

Dies wurde auch in diesem Thread an anderer Stelle erwähnt: https://.com/a/20827100/293492

Verwenden Sie nicht die Löschoption – sie hinterlässt eine Lücke im Array, da die Elemente nach dem gelöschten Element nicht neu indiziert werden.

> Array.prototype.remove=function(v)( ... delete this ... ); > var myarray=["3", "24", "55", "2"]; undefiniert > myarray.remove("55"); undefiniert > myarray [ "3", "24", "2" ]

Ein Liner wird es tun,

Var ary = ["drei", "sieben", "elf"]; // Element „seven“ aus Array entfernen var filteredAry = ary.filter(function(e) ( return e !== „seven“ )) //=> [„ three“, „eleven“] // In ECMA6 (arrow Funktionssyntax): var filteredAry = ary.filter(e => e !== "seven")

Dies nutzt die Filterfunktion in JS. Es wird in IE9 und höher unterstützt.

filter() ruft die bereitgestellte Rückruffunktion einmal für jedes Element im Array auf und erstellt ein neues Array aller Werte, für die der Rückruf einen Wert zurückgibt, der als wahr ausgewertet wird. Rückruf wird nur für Array-Indizes aufgerufen, denen Werte zugewiesen sind; Es wird nicht für Indizes aufgerufen, die gelöscht wurden oder denen nie Werte zugewiesen wurden. Array-Elemente, die den Callback-Test nicht bestehen, werden einfach übersprungen und nicht in das neue Array aufgenommen.

Im Grunde ist es also dasselbe wie alle anderen for (var key in ary) ( ... )-Lösungen, außer dass for in als IE6 unterstützt wird.

Im Grunde ist ein Filter eine praktische Methode, die im Gegensatz zu einem for in-Konstruktor (AFAIK) viel schöner aussieht (und verkettet werden kann).

Prüfen Sie:

For(var i in array)( if(array[i]=="seven")( array.splice(i,1); break; ) )

und in der Funktion:

Funktion removeItem(array, item)( for(var i in array)( if(array[i]==item)( array.splice(i,1); break; ) ) ) removeItem(array, "seven");

Entfernen aller übereinstimmenden Elemente aus einem Array (nicht nur das erste, wie es hier die allgemeinste Antwort zu sein scheint):

While ($.inArray(item, array) > -1) ( array.splice($.inArray(item, array), 1); )

Ich habe jQuery für die schwere Arbeit verwendet, aber Sie wissen schon, ob Sie nativ arbeiten möchten.

Der Trick besteht darin, das Array von Anfang bis Anfang durchzugehen, damit Sie die Indizes nicht durcheinander bringen, wenn Sie Elemente entfernen.

Var deleteMe = function(arr, me)( var i = arr.length; while(i--) if(arr[i] === me) arr.splice(i,1); ) var arr = ["orange „“, „rot“, „schwarz“, „orange“, „weiß“, „orange“ ]; deleteMe(arr, "orange");

arr ist jetzt [„rot“, „schwarz“, „weiß“]

Funktion cleanArrayOfSpecificTerms(array,unwantedTermsArray) ( $.each(unwantedTermsArray, function(index, value) ( ​​​​var index = array.indexOf(value); if (index > -1) ( array.splice(index, 1); ) ) ); Array zurückgeben; )

Befolgen Sie zur Verwendung die folgenden Schritte:

Var notInclude = ["Nicht", "Nein", "Erster", "Letzter", "Vorheriger", "Nächster", "Hunde", "Katzen"]; var splitTerms = ["call", "log", "dogs", "cats", "topic", "change", "pricing"]; cleanArrayOfSpecificTerms(splitTerms,notInclude)

Ich habe versucht, die Funktionsmethode von jbaron oben zu verwenden, habe jedoch festgestellt, dass ich das ursprüngliche Array für die spätere Verwendung unverändert lassen und ein neues Array wie dieses erstellen muss:

Var newArray = referenceArray;

Funktion newArrRemoveItem(array, item, newArray)( for(var i = 0; i< array.length; i++) { if(array[i]!=item){ newArray.push(array[i]); } } }

Dann benutze ich es so:

Var VesselID = record.get("VesselID"); var otherVessels = new Array(); newArrRemoveItem(vesselArr,vesselID,otherVessels);

Jetzt bleibt der VesselArr intakt und jedes Mal, wenn ich den obigen Code ausführe, enthält das Array otherVessels alles außer dem letzten CAID-Element.

indexOf ist eine Option, aber ihre Implementierung durchsucht grundsätzlich das gesamte Array nach einem Wert, sodass die Ausführungszeit mit der Größe des Arrays zunimmt. (also in jedem Browser, glaube ich, ich habe nur Firefox überprüft).

Ich habe keinen IE6 zum Testen, aber ich würde es als sichere Sache bezeichnen, dass Sie auf diese Weise auf fast jedem Client-Rechner mindestens eine Million Array-Elemente pro Sekunde testen können. Wenn [Array-Größe] * [ Suchanfragen pro Sekunde] auf über eine Million anwachsen könnte, sollten Sie eine andere Implementierung in Betracht ziehen.

Grundsätzlich können Sie ein Objekt verwenden, um einen Index für Ihr Array zu erstellen, etwa so:

Var index=("drei":0, "sieben":1, "elf":2);

Jedes normale JavaScript-Framework erstellt einen Suchindex für solche Objekte, sodass Sie einen Schlüssel schnell in einen Wert übersetzen können, unabhängig davon, wie viele Eigenschaften das Objekt hat.

Dies ist nur eine grundlegende Methode. Je nach Bedarf können Sie mehrere Objekte und/oder Arrays kombinieren, um dieselben Daten schnell nach verschiedenen Eigenschaften durchsuchbar zu machen. Wenn Sie Ihre spezifischen Anforderungen spezifizieren, kann ich eine spezifischere Datenstruktur vorschlagen.

//Mit dieser Funktion können Sie ein gerades Array aus dem Array entfernen. var removeFromArr = function(arr, elem) ( var i, len = arr.length, new_arr = , sort_fn = function (a, b) ( return a - b; ); für ( i = 0; i< len; i += 1) { if (typeof elem === "object" && typeof arr[i] === "object") { if (arr[i].toString() === elem.toString()) { continue; } else { if (arr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) { continue; } } } if (arr[i] !== elem) { new_arr.push(arr[i]); } } return new_arr; }

Anwendungsbeispiel

Var arr = , "abc", 1, "1", 1]; removeFromArr(arr, 1); //["2", , "abc", "1"] var arr = [ , 2, "a", , ]; removeFromArr(arr, ); //]

Sei arr = ; console.log(arr); //Ergebnis let index = arr.indexOf(30); if (index > -1) ( arr.splice(index, 1); ) console.log(arr); //Ergebnis

Var index = array.indexOf("item"); if(index!=-1)( array.splice(index, 1); )

Der JavaScript-Löschoperator entfernt eine Eigenschaft von einem Objekt. Wenn keine weiteren Verweise auf dieselbe Eigenschaft vorhanden sind, wird sie schließlich automatisch freigegeben.

Die Quelle für dieses interaktive Beispiel ist in einem GitHub-Repository gespeichert. Wenn Sie zum interaktiven Beispielprojekt beitragen möchten, klonen Sie bitte https://github.com/mdn/interactive-examples und senden Sie uns eine Pull-Anfrage.

Jede mit var definierte Variable wird als nicht konfigurierbar markiert. Im folgenden Beispiel ist das Gehalt nicht konfigurierbar und kann nicht gelöscht werden. Im nicht strikten Modus gibt der Löschvorgang false zurück.

Funktion Employee() ( Gehalt löschen; var Gehalt; ) Employee();

Sehen wir uns an, wie sich derselbe Code im strikten Modus verhält. Anstatt false zurückzugeben, löst die Anweisung einen SyntaxError aus.

„strikt verwenden“; function Employee() ( delete Gehalt; // SyntaxError var Salary; ) // Ebenso löst jeder direkte Zugriff auf eine Funktion // mit delete einen SyntaxError aus. function DemoFunction() ( //etwas Code ) delete DemoFunction; // Syntax-Fehler

Im folgenden Beispiel löschen wir eine eigene Eigenschaft eines Objekts, während eine gleichnamige Eigenschaft in der Prototypenkette verfügbar ist:

Funktion Foo() ( this.bar = 10; ) Foo.prototype.bar = 42; var foo = new Foo(); // foo.bar ist mit der // eigenen Eigenschaft verknüpft. console.log(foo.bar); // 10 // Löschen Sie die eigene Eigenschaft im // foo-Objekt. foo.bar löschen; // gibt true zurück // foo.bar ist weiterhin in der // Prototypenkette verfügbar. console.log(foo.bar); // 42 // Löschen Sie die Eigenschaft auf dem Prototyp. Foo.prototype.bar löschen; // gibt true zurück // Die Eigenschaft „bar“ kann nicht mehr // von Foo geerbt werden, da sie // gelöscht wurde. console.log(foo.bar); // nicht definiert

Wenn Sie ein Array-Element löschen, hat dies keine Auswirkungen auf die Array-Länge. Dies gilt auch dann, wenn Sie das letzte Element des Arrays löschen.

Wenn der Löschoperator ein Array-Element entfernt, befindet sich dieses Element nicht mehr im Array. Im folgenden Beispiel werden Bäume mit delete entfernt.

Var-Bäume = [„Mammutbaum“, „Lorbeer“, „Zeder“, „Eiche“, „Ahorn“]; Bäume löschen; if (3 in Bäumen) ( // dies wird nicht ausgeführt)

Wenn Sie möchten, dass ein Array-Element vorhanden ist, aber einen undefinierten Wert hat, verwenden Sie den undefinierten Wert anstelle des Löschoperators. Im folgenden Beispiel wird „trees“ der Wert „undefiniert“ zugewiesen, das Array-Element ist jedoch weiterhin vorhanden:

Var-Bäume = [„Mammutbaum“, „Lorbeer“, „Zeder“, „Eiche“, „Ahorn“]; Bäume = undefiniert; if (3 in Bäumen) ( // dies wird ausgeführt)

Wenn Sie stattdessen ein Array-Element entfernen möchten, indem Sie den Inhalt des Arrays ändern, verwenden Sie die Splice-Methode. Im folgenden Beispiel werden Bäume mithilfe von splice vollständig aus dem Array entfernt:

Var-Bäume = [„Mammutbaum“, „Lorbeer“, „Zeder“, „Eiche“, „Ahorn“]; Bäume.splice(3,1); console.log(trees); // ["Redwood", "Bay", "Cedar", "Maple"]

Die Kompatibilitätstabelle auf dieser Seite wird aus strukturierten Daten generiert. Wenn Sie zu den Daten beitragen möchten, schauen Sie sich bitte https://github.com/mdn/browser-compat-data an und senden Sie uns eine Pull-Anfrage.

Kompatibilitätsdaten auf GitHub aktualisieren

Obwohl ECMAScript die Iterationsreihenfolge von Objekten von der Implementierung abhängig macht, scheint es, dass alle gängigen Browser eine Iterationsreihenfolge unterstützen, die darauf basiert, dass die früheste hinzugefügte Eigenschaft zuerst kommt (zumindest für Eigenschaften, die nicht im Prototyp enthalten sind). Wenn man jedoch im Internet Explorer „delete“ für eine Eigenschaft verwendet, kommt es zu einem verwirrenden Verhalten, das andere Browser daran hindert, einfache Objekte wie Objektliterale als geordnete assoziative Arrays zu verwenden. Im Explorer, während die Eigenschaft Wert ist tatsächlich auf undefiniert gesetzt. Wenn man später eine Eigenschaft mit demselben Namen wieder hinzufügt, wird die Eigenschaft in ihrem iteriert alt Position – nicht am Ende der Iterationssequenz, wie man es erwarten könnte, nachdem die Eigenschaft gelöscht und dann wieder hinzugefügt wurde.

Ich habe ein Array von Ganzzahlen und verwende die Methode .push(), um Elemente hinzuzufügen.

Gibt es eine einfache Möglichkeit, ein bestimmtes Element aus einem Array zu entfernen? Äquivalent zu etwas wie array.remove(int); ,

Ich sollte verwenden Base JavaScript - keiner Frames sind nicht erlaubt.

RemoveByIndex(,1) //=>

• Machen Sie es einfach, intuitiv und explizit (https://en.wikipedia.org/wiki/Occam%27s_razor)
• Machen Sie es unveränderlich (das ursprüngliche Array bleibt unverändert)
• Tun Sie dies mit Standard-JS-Funktionen. Wenn Ihr Browser diese nicht unterstützt, verwenden Sie ein Polyfill

In diesem Codebeispiel verwende ich die Funktion „array.filter(...)“, um unnötige Elemente aus einem Array zu entfernen. Diese Funktion ändert das ursprüngliche Array nicht und erstellt ein neues. Wenn Ihr Browser diese Funktion nicht unterstützt (z. B. IE vor Version 9 oder Firefox vor Version 1.5), erwägen Sie die Verwendung des Polyfill-Filters von Mozilla.

WICHTIG ES2015 „() => ()“ Pfeilfunktionssyntax wird im IE, Chrome vor Version 45, Firefox vor Version 22, Safari vor Version 10 überhaupt nicht unterstützt. Um die ES2015-Syntax in älteren Browsern zu verwenden, können Sie BabelJS verwenden

Ein zusätzlicher Vorteil dieser Methode besteht darin, dass Sie mehrere Elemente entfernen können

Let forDeletion = let arr = arr = arr.filter(item => !forDeletion.includes(item)) // !!! Lesen Sie weiter unten über die Unterstützung von array.includes(...)!!! console.log(arr) // [ 1, 4 ]

WICHTIG „array.includes(...)“ wird im IE, Chrome vor Version 47, Firefox vor Version 43, Safari vor Version 9 und Edge vor Version 14 überhaupt nicht unterstützt

Hier sind einige Möglichkeiten, ein Element aus einem Array zu entfernen mit JavaScript.

Alle beschriebenen Methoden verändern nicht das ursprüngliche Array, sondern erstellen stattdessen ein neues.

Nehmen wir an, Sie haben ein Array und möchten das Element an Position i entfernen.

Eine Möglichkeit ist die Verwendung von Slice() :

const items = ["a", "b", "c", "d", "e", "f"] const i = 3 const filteredItems = items.slice(0, i-1).concat(items. Slice(i, items.length)) console.log(filteredItems)

Slice() erstellt ein neues Array mit den empfangenen Indizes. Wir erstellen einfach ein neues Array – vom Anfang bis zum Index, den wir löschen möchten, und verketten ein weiteres Array von der ersten Position nach der von uns gelöschten bis zum Ende des Arrays.

In diesem Fall ist die Verwendung von filter() eine gute Option, die mehr bietet deklarativ ein Ansatz:

const items = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter(item => item !== valueToRemove) console.log(filteredItems)

Dies nutzt ES6-Pfeilfunktionen. Sie können herkömmliche Funktionen verwenden, um ältere Browser zu unterstützen:

const items = ["a", "b", "c", "d", "e", "f"] const valueToRemove = "c" const filteredItems = items.filter(function(item) ( return item != = valueToRemove )) console.log(filteredItems)

Oder Sie können Babel verwenden und den ES6-Code zurück in ES5 konvertieren, um ihn für ältere Browser besser lesbar zu machen, aber modernes JavaScript in Ihren Code schreiben.

Was wäre, wenn Sie statt eines Elements viele Elemente löschen möchten?

Lassen Sie uns die einfachste Lösung finden.

Sie können einfach eine Funktion erstellen und Elemente nacheinander entfernen:

const items = ["a", "b", "c", "d", "e", "f"] const removeItem = (items, i) => items.slice(0, i-1).concat (items.slice(i, items.length)) let filteredItems = removeItem(items, 3) filteredItems = removeItem(filteredItems, 5) //["a", "b", "c", "d"] Konsole. log(filteredItems)

Sie können nach Einbindung in die Callback-Funktion suchen:

const items = ["a", "b", "c", "d", "e", "f"] const ValuesToRemove = ["c", "d"] const filteredItems = items.filter(item => !valuesToRemove.includes(item)) // ["a", "b", "e", "f"] console.log(filteredItems)

splice() (nicht zu verwechseln mit Slice()) verändert das ursprüngliche Array und sollte vermieden werden.

Sie können ES6 verwenden.

Var array=["1",2",3",4",5",6"] var index = array.filter((value)=>value!="3");

["1", "2", "4", "5", "6"]

Das geht ganz einfach mit der Filtermethode:

Function remove(arrOriginal, elementToRemove)( return arrOriginal.filter(function(el)(return el !== elementToRemove)); ) console.log(remove(, 1));

Dadurch werden alle Elemente aus dem Array entfernt und es funktioniert auch schneller als die Kombination aus Slice und IndexOf

Sie sollten niemals ein Array eines Arrays mutieren. Weil es gegen das funktionale Programmiermuster verstößt. Mit der es6-Methode filter können Sie ein neues Array ohne Verweis auf das Array erstellen, das Sie ändern möchten.

Var myArray = ;

Nehmen wir an, Sie möchten 5 aus einem Array entfernen. Das können Sie einfach so machen.

MyArray = myArray.filter(value => value !== 5);

Dadurch erhalten Sie ein neues Array ohne den Wert, den Sie entfernen möchten. So wird das Ergebnis sein

; // 5 wurde aus diesem Array entfernt

Zum weiteren Verständnis können Sie die MDN-Dokumentation zum Array.filter-Filter lesen

Wenn Sie ein neues Array mit entfernten Positionen wünschen, können Sie jederzeit ein bestimmtes Element entfernen und das Array filtern. Es könnte notwendig sein, das Array-Objekt für Browser zu erweitern, die die Filtermethode nicht implementieren, aber auf lange Sicht ist es einfacher, da Sie nur Folgendes tun:

Var my_array = ; lösche mein_array; console.log(my_array.filter(function(a)(return typeof a !== "undefined";)));

Sollte angezeigt werden

Können Sie Filter verwenden, wenn Sie komplexe Objekte in einem Array haben? In Situationen, in denen $.inArray oder array.splice nicht so einfach zu verwenden sind. Vor allem, wenn die Objekte im Array vielleicht klein sind.

Wenn Sie beispielsweise ein Objekt mit einem ID-Feld haben und möchten, dass das Objekt aus dem Array entfernt wird:

This.array = this.array.filter(function(element, i) ( return element.id !== idToRemove; ));

Suchen Sie den Index des Array-Elements, das Sie entfernen möchten, und entfernen Sie diesen Index dann mit splice .

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

var array = ; console.log(array) var index = array.indexOf(5); if (index > -1) ( array.splice(index, 1); ) // array = console.log(array);

Der zweite zu spleißende Parameter ist die Anzahl der zu entfernenden Elemente. Beachten Sie, dass splice das Array an Ort und Stelle ändert und ein neues Array zurückgibt, das die entfernten Elemente enthält.

Sie haben 1 bis 9 Arrays und möchten 5 mit dem folgenden Code entfernen.

var numberArray = ; var newNumberArray = numberArray.filter(m => ( return m !== 5; )); console.log("neues Array, 5 entfernt", newNumberArray);

Wenn Sie mehrere Ex-Werte verwenden möchten: - 1,7,8

var numberArray = ; var newNumberArray = numberArray.filter(m => ( return (m !== 1) && (m !== 7) && (m !== 8); )); console.log("neues Array, 5 entfernt", newNumberArray);

Wenn Sie den Array-Wert im Ex-Array entfernen möchten:

var numberArray = ; var removebleArray = ; var newNumberArray = numberArray.filter(m => ( return !removebleArray.includes(m); )); console.log("neues Array, entfernt", newNumberArray);

Enthält unterstützten Browser – Link

Ich weiß, dass es bereits viele Antworten gibt, aber viele davon scheinen das Problem zu verkomplizieren. Hier ist eine einfache, rekursive Möglichkeit, alle Instanzen eines Schlüssels zu entfernen: Rufen Sie self auf, bis der Index gefunden wird. Ja, es funktioniert nur im Browser indexOf , aber es ist einfach und kann leicht ausgefüllt werden.

Offline-Funktion

Funktion removeAll(array, key)( var index = array.indexOf(key); if(index === -1) return; array.splice(index, 1); removeAll(array,key); )

Prototyp-Methode

Array.prototype.removeAll = function(key)( var index = this.indexOf(key); if(index === -1) return; this.splice(index, 1); this.removeAll(key); )

Array.prototype.removeItem = function(a) ( für (i = 0; i< this.length; i++) { if (this[i] == a) { for (i2 = i; i2 < this.length - 1; i2++) { this = this; } this.length = this.length - 1 return; } } } var recentMovies = ["Iron Man", "Batman", "Superman", "Spiderman"]; recentMovies.removeItem("Superman");