Wie man Artikel vom Array nach Wert entfernt?

Gibt es eine Methode, um ein Element aus einem JavaScript-Array zu entfernen?

Gegeben ein Array:

var ary = ['three', 'seven', 'eleven']; 

Ich möchte etwas tun wie:

 removeItem('seven', ary); 

Ich habe splice() aber das wird nur durch die Positionsnummer entfernt, während ich etwas brauche, um ein Element nach seinem Wert zu entfernen.

Dies kann eine globale function oder eine Methode eines benutzerdefinierten Objekts sein, wenn Sie keine nativen Prototypen hinzufügen dürfen. Es entfernt alle Elemente aus dem Array, die mit einem der Argumente übereinstimmen.

 Array.prototype.remove = function() { var what, a = arguments, L = a.length, ax; while (L && this.length) { what = a[--L]; while ((ax = this.indexOf(what)) !== -1) { this.splice(ax, 1); } } return this; }; var ary = ['three', 'seven', 'eleven']; ary.remove('seven'); /* returned value: (Array) three,eleven */ 

Um es global zu machen

 function removeA(arr) { var what, a = arguments, L = a.length, ax; while (L > 1 && arr.length) { what = a[--L]; while ((ax= arr.indexOf(what)) !== -1) { arr.splice(ax, 1); } } return arr; } var ary = ['three', 'seven', 'eleven']; removeA(ary, 'seven'); /* returned value: (Array) three,eleven */ 

Und um IE8 und darunter zu kümmern

 if(!Array.prototype.indexOf) { Array.prototype.indexOf = function(what, i) { i = i || 0; var L = this.length; while (i < L) { if(this[i] === what) return i; ++i; } return -1; }; } 

Sie können die Methode indexOf wie indexOf verwenden :

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

Hinweis : Sie müssen es für IE8 und darunter shim

 var array = [1,2,3,4] var item = 3 var index = array.indexOf(item); if (index !== -1) array.splice(index, 1); console.log(array) 

Ein One-Liner wird es tun,

 var ary = ['three', 'seven', 'eleven']; // Remove item 'seven' from array var filteredAry = ary.filter(function(e) { return e !== 'seven' }) //=> ["three", "eleven"] // In ECMA6 (arrow function syntax): var filteredAry = ary.filter(e => e !== 'seven') 

Dies macht Gebrauch von der Filterfunktion in JS. Es wird in IE9 und höher unterstützt.

Was es tut (aus dem Doc-Link)

filter () ruft eine bereitgestellte Callback-function einmal für jedes Element in einem Array auf und konstruiert ein neues Array aller Werte, für die der Callback einen Wert zurückgibt, der auf true verweist. Callback wird nur für Indizes des Arrays 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 sind nicht im neuen Array enthalten.

Im Grunde ist dies das Gleiche wie für alle anderen for (var key in ary) { ... } Lösungen, außer dass das for in Konstrukt ab IE6 unterstützt wird.

Grundsätzlich ist Filter eine Bequemlichkeitsmethode, die im Vergleich zum for in Konstrukt (AFAIK) viel schöner aussieht (und kettenfähig ist).

Sie können unterscore.js verwenden . Es macht die Dinge wirklich einfach.

Zum Beispiel mit:

 var result = _.without(['three','seven','eleven'], 'seven'); 

Und das result wird ['three','eleven'] .

In Ihrem Fall ist der Code, den Sie schreiben müssen:

 ary = _.without(ary, 'seven') 

Es reduziert den Code, den Sie schreiben.

Schau dir diesen Weg an:

 for(var i in array){ if(array[i]=='seven'){ array.splice(i,1); break; } } 

und in einer function:

 function removeItem(array, item){ for(var i in array){ if(array[i]==item){ array.splice(i,1); break; } } } removeItem(array, 'seven'); 

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

 var index = $.inArray(item, array); if (index != -1) { array.splice(index, 1); } 
 var index = array.indexOf('item'); if(index!=-1){ array.splice(index, 1); } 

Sie können es mit diesen beiden Möglichkeiten tun:

 var arr = ["1","2","3","4"] // we wanna delete number "3" 

zuerst:

 arr.indexOf('3') !== -1 && arr.splice(arr.indexOf('3'), 1) 

zweite (ES6):

 arr = arr.filter(e => e !== '3') 

Was Sie suchen, ist Filter

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

Dadurch können Sie Folgendes tun:

 var ary = ['three', 'seven', 'eleven']; var aryWithoutSeven = ary.filter(function(value) { return value != 'seven' }); console.log(aryWithoutSeven); // returns ['three', 'eleven'] 

Dies wurde auch in diesem Thread woanders notiert: https://stackoverflow.com/a/20827100/293492

Da es keine schöne ist, hier ist eine einfache und wiederverwendbare ES6-function.

 const removeArrayItem = (arr, itemToRemove) => { return arr.filter(item => item !== itemToRemove) } 

Verwendung:

 const items = ['orange', 'purple', 'orange', 'brown', 'red', 'orange'] removeArrayItem(items, 'orange') 

Eine sehr saubere Lösung, die in allen Browsern und ohne jegliches Framework funktioniert, besteht darin, ein neues Array zuzuordnen und es einfach ohne das Objekt, das Sie löschen möchten, zurückzugeben:

 /** * @param {Array} array the original array with all items * @param {any} item the time you want to remove * @returns {Array} a new Array without the item */ var removeItemFromArray = function(array, item){ /* assign a empty array */ var tmp = []; /* loop over all array items */ for(var index in array){ if(array[index] !== item){ /* push to temporary array if not like item */ tmp.push(array[index]); } } /* return the temporary array */ return tmp; } 

Entfernen aller übereinstimmenden Elemente aus dem Array (und nicht nur die erste, die hier am häufigsten verwendet wird):

 while ($.inArray(item, array) > -1) { array.splice( $.inArray(item, array), 1 ); } 

Ich habe jQuery für das Heavy Lifting verwendet, aber Sie bekommen die Idee, wenn Sie nativ werden wollen.

Wenn Sie in Ihrem Array eindeutige Werte haben und die Reihenfolge nicht wichtig ist, können Sie Set verwenden und es hat gelöscht :

 var mySet = new Set(['foo']); mySet.delete('foo'); // Returns true. Successfully removed. mySet.has('foo'); // Returns false. The "foo" element is no longer present. 

indexOf ist eine Option, aber bei der Implementierung wird im Grunde das gesamte Array nach dem Wert durchsucht, sodass die Ausführungszeit mit der Array-Größe wächst. (so ist es in jedem Browser ich denke, ich habe nur Firefox überprüft).

Ich habe kein IE6 um zu überprüfen, aber ich würde es eine sichere Wette nennen, dass Sie so mindestens eine Million Array-Elemente pro Sekunde auf fast jedem Client-Rechner überprüfen können. Wenn [Array-Größe] * [Suchvorgänge pro Sekunde] größer als eine Million werden kann, 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:

 var index={'three':0, 'seven':1, 'eleven':2}; 

Jede vernünftige JavaScript-Umgebung erstellt einen durchsuchbaren Index für solche Objekte, sodass Sie einen Schlüssel schnell in einen Wert übersetzen können, unabhängig davon, wie viele Eigenschaften das Objekt besitzt.

Dies ist nur die grundlegende Methode, je nach Bedarf können Sie mehrere Objekte und / oder Arrays kombinieren, um dieselben Daten schnell für verschiedene Eigenschaften durchsuchbar zu machen. Wenn Sie Ihre genauen Bedürfnisse angeben, kann ich eine spezifischere Datenstruktur vorschlagen.

Der Trick besteht darin, das Array von Ende zu Anfang durchzugehen, damit Sie die Indizes beim Entfernen von Elementen nicht durcheinander bringen.

 var deleteMe = function( arr, me ){ var i = arr.length; while( i-- ) if(arr[i] === me ) arr.splice(i,1); } var arr = ["orange","red","black", "orange", "white" , "orange" ]; deleteMe( arr , "orange"); 

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

ES6 Weg.

 let commentsWithoutDeletedArray = commentsArray.filter( (comment) => !(comment.Id === commentId)); 

Zerstörungsfreie Entfernung:

 function removeArrayValue(array, value) { var thisArray = array.slice(0); // copy the array so method is non-destructive var idx = thisArray.indexOf(value); // initialise idx while(idx != -1) { thisArray.splice(idx, 1); // chop out element at idx idx = thisArray.indexOf(value); // look for next ocurrence of 'value' } return thisArray; } 

Wirklich, ich kann nicht sehen, warum das nicht mit getriggers werden kann

 arr = arr.filter(value => value !== 'seven'); 

Oder vielleicht möchtest du Vanille JS benutzen

 arr = arr.filter(function(value) { return value !== 'seven' }); 

Bitte verwenden Sie die Variante mit delete – sie erzeugt ein Loch im Array, da die Elemente nach dem gelöschten Objekt nicht neu indiziert werden.

 > Array.prototype.remove=function(v){ ... delete this[this.indexOf(v)] ... }; [Function] > var myarray=["3","24","55","2"]; undefined > myarray.remove("55"); undefined > myarray [ '3', '24', , '2' ] 

Ich habe die am meisten gewählte Option verwendet und eine function erstellt, die ein Array von Wörtern mit einem anderen Array von unerwünschten Wörtern bereinigt:

 function cleanArrayOfSpecificTerms(array,unwantedTermsArray) { $.each(unwantedTermsArray, function( index, value ) { var index = array.indexOf(value); if (index > -1) { array.splice(index, 1); } }); return array; } 

Gehen Sie folgendermaßen vor, um zu verwenden:

 var notInclude = ['Not','No','First','Last','Prior','Next', 'dogs','cats']; var splitTerms = ["call", "log", "dogs", "cats", "topic", "change", "pricing"]; cleanArrayOfSpecificTerms(splitTerms,notInclude) 
 function removeFrmArr(array, element) { return array.filter(e => e !== element); }; var exampleArray = [1,2,3,4,5]; removeFrmArr(a, 3); // return value like this //[1, 2, 4, 5] 

Sie können without Lodash verwenden oder pull :

 const _ = require('lodash'); _.without([1, 2, 3, 2], 2); // -> [1, 3] 
 let arr = [5, 15, 25, 30, 35]; console.log(arr); //result [5, 15, 25, 30, 35] let index = arr.indexOf(30); if (index > -1) { arr.splice(index, 1); } console.log(arr); //result [5, 15, 25, 35] 
 var remove = function(array, value) { var index = null; while ((index = array.indexOf(value)) !== -1) array.splice(index, 1); return array; }; 

Ich habe versucht, die function Methode von Jbaron oben zu verwenden, fand aber, dass ich das ursprüngliche Array für die spätere Verwendung intakt halten musste, und ein neues Array wie folgt erstellen:

 var newArray = referenceArray; 

anscheinend erstellt durch Verweis anstelle von Wert, denn wenn ich ein Element aus newArray entfernt, hat das ReferenceArray es auch entfernt. Also habe ich beschlossen, jedes Mal ein neues Array zu erstellen:

 function 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 in einer anderen function:

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

Jetzt bleibt der vesselArr intakt, während jedes andere vessels-Array jedes Mal, wenn ich den obigen Code ausführe, alle bis auf das letzte vesselID-Element enthält.

CoffeeScript + jQuery Variante:

 arrayRemoveItemByValue = (arr,value) -> r=$.inArray(value, arr) unless r==-1 arr.splice(r,1) # return arr console.log arrayRemoveItemByValue(['2','1','3'],'3') 

es entfernt nur einen, nicht alle.

 //This function allows remove even array from array var removeFromArr = function(arr, elem) { var i, len = arr.length, new_arr = [], sort_fn = function (a, b) { return a - b; }; for (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 = [1, '2', [1 , 1] , 'abc', 1, '1', 1]; removeFromArr(arr, 1); //["2", [1, 1], "abc", "1"] var arr = [[1, 2] , 2, 'a', [2, 1], [1, 1, 2]]; removeFromArr(arr, [1,2]); //[2, "a", [1, 1, 2]] 

Eine andere Variante:

 if (!Array.prototype.removeArr) { Array.prototype.removeArr = function(arr) { if(!Array.isArray(arr)) arr=[arr];//let's be nice to people who put a non-array value here.. that could be me! var that = this; if(arr.length){ var i=0; while(i-1){ that.splice(i,1); }else i++; } } return that; } } 

Es ist wieder indexOf () innerhalb einer Schleife, aber unter der Annahme, dass das zu entfernende Array relativ zum zu bereinigenden Array klein ist; Jede Entfernung verkürzt die While-Schleife.

// editiert dank MarcoCI für den Hinweis

Versuche dies:

 function wantDelete(item, arr){ for (var i=0;i 

hoffe das hilft dir

In einer globalen function können wir keinen benutzerdefinierten Wert direkt übergeben, aber es gibt viele Wege wie unten

  var ary = ['three', 'seven', 'eleven']; var index = ary.indexOf(item);//item: the value which you want to remove //Method 1 ary.splice(index,1); //Method 2 delete ary[index]; //in this method the deleted element will be undefined