如何按值从数组中删除项？

Question

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

给定一个数组:

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

我想做的事情如下:

removeItem('seven', ary);

我已经调查了splice()但只能通过位置编号删除,而我需要通过其值删除项目.

Answer 1

你可以使用这样的indexOf方法:

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

注意:您需要为IE8及以下版本填充它

var array = [1,2,3,4]
var item = 3

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

console.log(array)

Answer 2

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

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 3

单行将会这样做,

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 中的过滤器功能.IE9及以上版本支持它.

它的作用(来自doc链接)

filter()为数组中的每个元素调用一次提供的回调函数,并构造一个包含所有值的新数组,其中回调返回一个强制为true的值.仅为已分配值的数组的索引调用回调; 对于已删除的索引或从未分配过值的索引,不会调用它.不会通过回调测试的数组元素被简单地跳过,并且不包含在新数组中.

所以基本上,这与所有其他for (var key in ary) { ... }解决方案相同,只是for in从IE6开始支持该构造.

基本上,过滤器是一种方便的方法,与for in构造(AFAIK)相比,看起来更好(并且是可链接的).

Answer 4

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

例如,有了这个:

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

而且result会['three','eleven'].

在您的情况下,您必须编写的代码是:

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

它减少了你编写的代码.

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

您可以通过以下两种方式实现:

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

Answer 7

您可以创建自己的方法，传递数组和要删除的值：

function removeItem(arr, item){
 return arr.filter(f => f !== item)
}

然后你可以调用它：

ary = removeItem(ary, 'seven');

Answer 8

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

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

Answer 9

var index = array.indexOf('item');

if(index!=-1){

   array.splice(index, 1);
}

Answer 10

只是

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

Answer 11

您所追求的是过滤器

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 12

最简单的解决方案是：

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

Answer 13

看起来没有漂亮的,这是一个简单且可重复使用的ES6功能.

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

用法:

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

Answer 14

ES6的方式.

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

Answer 15

真的,我不明白为什么这不能解决

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

或许你想要使用香草JS

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

Answer 16

如果您的数组中有唯一值并且排序无关紧要,则可以使用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.

Answer 17

从数组中删除所有匹配的元素(而不是仅仅是第一个,这似乎是最常见的答案):

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

我使用jQuery来进行繁重的工作,但如果你想成为原生人,你就会明白这一点.

Answer 18

当您需要删除数组中多次出现的值时（例如[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]

Answer 19

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

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]

Answer 20

在所有浏览器中运行并且没有任何框架的非常干净的解决方案是将新数组作为一个新数组并在没有要删除的项目的情况下返回它:

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

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

我没有要检查的 IE6，但我认为这是一个安全的赌注，您可以在几乎任何客户端机器上以这种方式每秒检查至少一百万个数组项。如果 [数组大小]*[每秒搜索次数] 可能增长到超过一百万，您应该考虑不同的实现。

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

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

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

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

Answer 22

您可以使用Lodash _.remove函数来实现这一点。

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

console.log(evens);

<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/lodash@4.17.10/lodash.min.js"></script>