如何通过值从数组中删除项目？

有没有从JavaScript数组中删除项目的方法？

给定一个数组：

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

我想做一些事情：

 removeItem('seven', ary); 

我已经研究过splice()但只能删除位置号码，而我需要通过它的值删除一个项目。

Answer 1

如果您不允许添加到本机原型，则这可以是全局函数或自定义对象的方法。 它将删除数组中与所有参数匹配的所有项目。

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

为了使其成为一个全球性

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

为了照顾IE8和以下版本，

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

Answer 2

你正在寻找indexOf方法
例如：

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

请注意，您需要为IE 8及以下版本添加它 。

Answer 3

一个class轮将做到这一点，

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

这使得在JS中使用filterfunction。 它在IE9和以上支持。

它做什么（从文档链接）

filter（）为数组中的每个元素调用一次提供的callback函数，并为所有的callback函数返回一个强制为true的值构造一个新的数组。 callback仅针对已赋值的数组的索引进行调用; 对于已被删除或从未被赋值的索引，不会调用它。 不通过callbacktesting的数组元素会被忽略，并且不包含在新数组中。

所以基本上，这与for (var key in ary) { ... }解决scheme中的所有其他方法是一样的，除了IE6支持for in构造。

基本上，filter是一个方便的方法，看起来好多了（而且是可链接的），而不是for in构造（AFAIK）。

Answer 4

你可以使用underscore.js 。 这真的让事情变得简单。

例如，用这个：

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

result将是['three','eleven'] 。

在你的情况下，你将不得不写的代码是：

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

它减less了你写的代码。

Answer 5

这样看看：

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

并在一个函数中：

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

Answer 6

这是一个使用jQuery的inArray函数的版本：

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

Answer 7

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

Answer 8

你之后是filter

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

这将允许您执行以下操作：

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

这也是在这个线程中的其他地方注意到： https : //stackoverflow.com/a/20827100/293492

Answer 9

鉴于没有一个漂亮的，这是一个简单的和可重用的ES6function。

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

用法：

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

Answer 10

从数组中删除所有匹配的元素（而不仅仅是第一个，这似乎是这里最常见的答案）：

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

我用jQuery进行繁重的工作，但是如果你想要本地化的话，你会明白。

Answer 11

一个在所有浏览器中工作且没有任何框架的非常干净的解决scheme是devise一个新的Array，并简单地返回它，而不需要你想要删除的项目：

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

Answer 12

indexOf是一个选项，但它的实现基本上是search整个数组的值，所以执行时间随着数组大小而增长。 （所以这是在每个浏览器我猜，我只检查Firefox）。

我还没有一个IE6来检查，但我敢打赌，你几乎可以在任何客户端机器上每秒至less检查一百万个数组项。 如果[数组大小] * [每秒search次数]可能增长超过一百万，则应考虑不同的实现。

基本上你可以使用一个对象来为你的数组创build索引，如下所示：

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

任何理智的JavaScript环境都会为这些对象创build一个可search的索引，这样无论对象有多less属性，都可以快速地将一个键转换为一个值。

这只是基本的方法，根据您的需要，您可以组合多个对象和/或数组，以便为​​不同的属性快速search相同的数据。 如果您指定确切的需求，我可以build议一个更具体的数据结构。

Answer 13

诀窍是从头到尾遍历数组，所以在删除元素时不要搞乱索引。

 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现在是[“红”，“黑”，“白”]

Answer 14

ES6的方式。

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

Answer 15

请不要使用带有delete的变体 – 它会在数组中创build一个空洞，因为它不会重新索引删除项目之后的元素。

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

Answer 16

我使用了最受欢迎的选项，并创build了一个函数，使用另一个不需要的单词来清理一个单词的数组：

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

要使用，请执行以下操作：

 var notInclude = ['Not','No','First','Last','Prior','Next', 'dogs','cats']; var splitTerms = ["call", "log", "dogs", "cats", "topic", "change", "pricing"]; cleanArrayOfSpecificTerms(splitTerms,notInclude) 

Answer 17

无损拆除：

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

Answer 18

如果你的数组中有唯一的值，你可以使用Set ，它有删除 ：

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

Answer 19

 var remove = function(array, value) { var index = null; while ((index = array.indexOf(value)) !== -1) array.splice(index, 1); return array; }; 

Answer 20

我尝试从上面的jbaron使用函数的方法，但发现我需要保持原来的数组以下使用，并创build一个新的数组，像这样：

 var newArray = referenceArray; 

显然是通过引用而不是值来创build的，因为当我从newArray中移除一个元素的时候，referenceArray也被删除了。 所以我决定每次都这样创build一个新的数组：

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

然后我在另一个函数中使用它：

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

现在vesselArr保持不变，而每次我执行上面的代码时，otherVessels数组除了最新的vesselID元素。

Answer 21

CoffeeScript + jQuery变体：

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

它只删除一个，不是全部。

Answer 22

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

使用示例

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

Answer 23

另一个变化：

 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<that.length){ if(arr.indexOf(that[i])>-1){ that.splice(i,1); }else i++; } } return that; } } 

它又是一个循环内的indexOf（），但是假设要移除的数组相对于要清理的数组相对较小; 每次移除都会缩短while循环。

Answer 24

强烈build议Lodash这样的微不足道的操作：

 var lodash = require('lodash'); var arr = [1, 2, 3, 2]; lodash.pull(arr, 2); // -> [1, 3] 

Answer 25

感谢MarcoCI的build议

尝试这个：

 function wantDelete(item, arr){ for (var i=0;i<arr.length;i++){ if (arr[i]==item){ arr.splice(i,1); //this delete from the "i" index in the array to the "1" length break; } } } var goodGuys=wantDelete('bush', ['obama', 'bush', 'clinton']); //['obama', 'clinton'] 

希望这对你有所帮助

Answer 26

你可以使用indexOf方法解决这个问题。

首先，find你想要删除的元素的索引：

 var ary = ['three', 'seven', 'eleven']; var index = ary.indexOf('seven'); 

然后使用拼接方法删除它：

 if (index > -1) { ary.splice(index, 1); } 

NB：浏览器对indexOf的支持是有限的; 它在Internet Explorer 7和8中不受支持。请在此处查看

Answer 27

  var array = [1,2,3,4,5,6,7,8,9,10]; array.splice(array.indexOf(array), 1);//Answer is [10];