Comment supprimer un élément du tableau par valeur?

Existe-t-il une méthode pour supprimer un élément d’un tableau JavaScript?

Étant donné un tableau:

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

Je voudrais faire quelque chose comme:

 removeItem('seven', ary); 

J’ai examiné splice() mais cela ne disparaît que par le numéro de position, alors que j’ai besoin de quelque chose pour supprimer un élément de sa valeur.

Cela peut être une fonction globale ou une méthode d’un object personnalisé, si vous n’êtes pas autorisé à l’append à des prototypes natifs. Il supprime tous les éléments du tableau qui correspondent à l’un des arguments.

 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 */ 

Pour en faire un monde globalisé

 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 */ 

Et s’occuper de IE8 et au-dessous-

 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; }; } 

Vous pouvez utiliser la méthode indexOf comme ceci:

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

Remarque : vous devrez le caler pour IE8 et les versions ultérieures

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

Un one-liner le fera,

 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') 

Cela utilise la fonction de filtre dans JS. Il est pris en charge dans IE9 et les versions ultérieures.

Ce qu’il fait (à partir du lien doc)

filter () appelle une fonction de rappel fournie une fois pour chaque élément d’un tableau, et construit un nouveau tableau de toutes les valeurs pour lesquelles le rappel renvoie une valeur qui devient vraie. le rappel n’est appelé que pour les index du tableau qui ont des valeurs assignées; il n’est pas appelé pour les index qui ont été supprimés ou qui n’ont jamais reçu de valeurs. Les éléments de tableau qui ne réussissent pas le test de rappel sont simplement ignorés et ne sont pas inclus dans le nouveau tableau.

Donc, fondamentalement, c’est la même chose que pour toutes les solutions for (var key in ary) { ... } , sauf que la construction for in est prise en charge à partir d’IE6.

Fondamentalement, filter est une méthode pratique qui est beaucoup plus agréable (et qui est chaînable) que la méthode for in (AFAIK).

Vous pouvez utiliser underscore.js . Cela simplifie vraiment les choses.

Par exemple, avec ceci:

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

Et le result sera ['three','eleven'] .

Dans votre cas, le code que vous devrez écrire est le suivant:

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

Cela réduit le code que vous écrivez.

Découvrez cette façon:

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

et dans une fonction:

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

Voici une version qui utilise la fonction inArray de jQuery:

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

Vous pouvez le faire avec ces deux manières:

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

premier:

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

deuxième (ES6):

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

Ce que vous recherchez est un filtre

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

Cela vous permettra de faire ce qui suit:

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

Cela a également été noté dans ce fil quelque part ailleurs: https://stackoverflow.com/a/20827100/293492

En voyant qu’il n’y en a pas de beau, voici une fonction ES6 simple et réutilisable.

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

Usage:

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

Une solution très propre fonctionnant dans tous les navigateurs et sans aucune infrastructure consiste à atsortingbuer un nouveau tableau et à le retourner simplement sans l’élément que vous souhaitez supprimer:

 /** * @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; } 

Enlever tous les éléments correspondants du tableau (plutôt que le premier comme cela semble être la réponse la plus courante ici):

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

J’ai utilisé jQuery pour le levage de charges lourdes, mais vous avez compris si vous vouliez devenir natif.

Si vous avez des valeurs uniques dans votre tableau et que le classement n’a pas d’importance, vous pouvez utiliser Set et supprimer :

 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 est une option, mais son implémentation consiste essentiellement à rechercher la valeur dans l’ensemble du tableau, de sorte que le temps d’exécution augmente avec la taille du tableau. (donc c’est dans tous les navigateurs que je suppose, j’ai seulement vérifié Firefox).

Je n’ai pas eu d’IE6 à vérifier, mais je parie que vous pouvez vérifier au moins un million d’éléments de tableau par seconde sur presque toutes les machines clientes. Si [taille du tableau] * [recherches par seconde] peut dépasser le million, vous devriez envisager une implémentation différente.

En gros, vous pouvez utiliser un object pour créer un index pour votre tableau, comme ceci:

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

Tout environnement JavaScript sain créera un index de recherche pour ces objects afin que vous puissiez rapidement traduire une clé en une valeur, quel que soit le nombre de propriétés de l’object.

Ceci est juste la méthode de base, en fonction de vos besoins, vous pouvez combiner plusieurs objects et / ou tableaux pour rendre les mêmes données rapidement consultables pour différentes propriétés. Si vous spécifiez vos besoins exacts, je peux suggérer une structure de données plus spécifique.

L’astuce consiste à parcourir le tableau de bout en bout, afin de ne pas gâcher les index tout en supprimant des éléments.

 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 est maintenant [“red”, “black”, “white”]

Manière ES6.

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

Enlèvement non destructif:

 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; } 

Vraiment, je ne vois pas pourquoi cela ne peut pas être résolu avec

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

Ou peut-être que vous voulez utiliser la vanille JS

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

Veuillez ne pas utiliser la variante avec delete – elle crée un trou dans le tableau car il ne réindexe pas les éléments après l’élément supprimé.

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

J’ai utilisé l’option la plus votée et créé une fonction qui nettoierait un tableau de mots en utilisant un autre tableau de mots indésirables:

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

Pour utiliser, procédez comme suit:

 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] 

Vous pouvez utiliser without ou pull de Lodash :

 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; }; 

J’ai essayé d’utiliser la méthode de fonction de jbaron ci-dessus mais j’ai constaté que je devais conserver le tableau d’origine intact pour l’utiliser plus tard et créer un nouveau tableau comme celui-ci:

 var newArray = referenceArray; 

apparemment crée par référence au lieu de valeur car lorsque j’ai supprimé un élément de newArray, le referenceArray l’avait également supprimé. J’ai donc décidé de créer un nouveau tableau à chaque fois comme ceci:

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

Alors je l'utilise comme ça dans une autre fonction:

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

Maintenant, le shipArr rest intact alors que chaque fois que j'exécute le code ci-dessus, le tableau otherVessels inclut tous les éléments exceptés le shipID.

CoffeeScript + variante jQuery:

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

il n’en retire qu’un, pas tous.

 //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; } 

Exemple d'utilisation

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

Une autre 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; } } 

C’est indexOf () à l’intérieur d’une boucle, mais en supposant que le tableau à supprimer est petit par rapport au tableau à nettoyer; chaque enlèvement raccourcit la boucle while.

// édité grâce à MarcoCI pour les conseils

essaye ça:

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

j'espère que cela vous aidera

Dans une fonction globale, nous ne pouvons pas passer directement une valeur personnalisée, mais il y a de nombreuses manières comme ci-dessous

  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