本文共 9065 字，大约阅读时间需要 30 分钟。

有没有一种方法可以从数组中删除项目？

给定一个数组：

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

我想做类似的事情：

removeItem('seven', ary);

我已经研究过splice()但是它只能通过位置编号删除，而我需要一些东西才能通过其值删除项目。

#1楼

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

#2楼

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

#3楼

您可以使用 。 这确实使事情变得简单。

例如，与此：

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

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

在您的情况下，您必须编写的代码是：

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

它减少了您编写的代码。

#4楼

我尝试使用上述jbaron中的function方法，但发现需要保持原始数组完整以备后用，并创建一个新数组，如下所示：

var newArray = referenceArray;

显然是通过引用而不是值创建的，因为当我从newArray中删除元素时，referenceArray也已将其删除。 因此，我决定每次都创建一个新数组，如下所示：

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元素以外的所有元素。

#5楼

这是使用jQuery的的版本：

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

#6楼

CoffeeScript + jQuery变体：

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

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

#7楼

一口气就能做到

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

这利用了JS中的函数。 在IE9及更高版本中受支持。

它的作用（来自doc链接）

filter（）为数组中的每个元素调用一次提供的回调函数，并构造一个所有值的新数组，为此，回调返回一个强制为true的值。 仅对具有指定值的数组索引调用回调； 对于已删除或从未分配值的索引，不会调用它。 仅跳过未通过回调测试的数组元素，并且不包含在新数组中。

因此，基本上，这与所有其他for (var key in ary) { ... }解决方案相同，除了从IE6开始支持构造。

基本上，过滤器是一种方便的方法，与for in结构（AFAIK）相比，它看起来更好（并且可链接）。

#8楼

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

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

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

#9楼

请不要将变体与delete -它会在数组中打孔，因为它不会在删除项目后重新索引元素。

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

#10楼

您所追求的是过滤器

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

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

此线程在其他地方也指出了这一点： :

#11楼

我使用投票最多的选项，并创建了一个函数，该函数将使用另一组不需要的单词来清理一个单词数组：

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)

#12楼

诀窍是从头到尾遍历数组，因此在删除元素时不会弄乱索引。

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为[“ red”，“ black”，“ white”]

#13楼

在所有浏览器中且没有任何框架的情况下，一个非常干净的解决方案是分配一个新的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;}

#14楼

您可以使用without或pull从 ：

const _ = require('lodash');_.without([1, 2, 3, 2], 2); // -> [1, 3]

#15楼

无损清除：

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

#16楼

您可以像这样使用 ：

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

注意 ：

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

#17楼

indexOf是一个选项，但是它的实现基本上是在整个数组中搜索该值，因此执行时间随数组大小而增加。 （所以我猜它在每个浏览器中都只检查了Firefox）。

我还没有IE6可以检查，但是我可以肯定地说，您几乎可以在几乎所有客户端计算机上以这种方式每秒检查至少一百万个数组项目。 如果[数组大小] * [每秒搜索次数]可能大于一百万，则应考虑使用其他实现。

基本上，您可以使用一个对象为数组创建索引，如下所示：

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

任何理智的JavaScript环境都将为此类对象创建可搜索的索引，以便您可以快速将键转换为值，无论对象具有多少属性。

这只是基本方法，您可以根据需要将多个对象和/或数组组合在一起，以使同一数据可快速搜索到不同的属性。 如果您指定确切的需求，我可以建议更具体的数据结构。

#18楼

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

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

#19楼

如果您的数组中有唯一值，而排序无所谓，则可以使用Set ，它具有delete ：

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

#20楼

ES6方式。

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

#21楼

似乎没有一个漂亮的功能，这是一个简单且可重用的ES6函数。

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

用法：

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

#22楼

您可以通过以下两种方式进行操作：

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

第一：

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

第二（ES6）：

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

#23楼

当您需要删除数组中多次出现的值时（例如[1,2,2,2,4,5,6]）。

function removeFrmArr(array, element) {      return array.filter(e => e !== element);    };    var exampleArray = [1,2,3,4,5];    removeFrmArr(exampleArray, 3);    // return value like this    //[1, 2, 4, 5]

您可以使用splice从数组中删除单个元素，但是splice无法从数组中删除多个类似元素。

function singleArrayRemove(array, value){  var index = array.indexOf(value);  if (index > -1) array.splice(index, 1);  return array;}var exampleArray = [1,2,3,4,5,5];singleArrayRemove(exampleArray, 5);// return value like this//[1, 2, 3, 4, 5]

#24楼

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]

#25楼

在全局函数中，我们不能直接传递自定义值，但是有很多方法如下

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

#26楼

真的，我看不出为什么无法解决

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

或者也许您想使用香草JS

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

#27楼

您可以使用Lodash 函数来实现。

var array = ['three', 'seven', 'eleven']; var evens = _.remove(array, function(e) { return e !== 'seven'; }); console.log(evens);

#28楼

只是

var ary = ['three', 'seven', 'eleven'];var index = ary.indexOf('seven'); // get index if value found otherwise -1 if (index > -1) { //if found   ary.splice(index, 1); }

#29楼

在所有唯一值中，您可以：

a = new Set([1,2,3,4,5]) // a = Set(5) {1, 2, 3, 4, 5}a.delete(3) // a = Set(5) {1, 2, 4, 5} [...a] // [1, 2, 4, 5]

#30楼

最简单的解决方案是：

array-用于删除某些元素的数组valueForRemove; valueForRemove-要删除的元素；

array.filter(arrayItem => !array.includes(valueForRemove));

更简单：

array.filter(arrayItem => arrayItem !== valueForRemove);

不漂亮，但是可以工作：

array.filter(arrayItem => array.indexOf(arrayItem) != array.indexOf(valueForRemove))

不漂亮，但是可以工作：

while(array.indexOf(valueForRemove) !== -1) {  array.splice(array.indexOf(valueForRemove), 1)}

#31楼

以这种方式签出：

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

转载地址：http://tpdnb.baihongyu.com/