关于javascript：如何通过值从数组中删除项？


How to remove item from array by value?

是否有从javascript数组中移除项的方法？

给定数组：

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

我想做如下的事情：

1
removeItem('seven', ary);

我已经研究过splice()，但这只会根据位置号删除，而我需要一些东西根据项目的值删除项目。

相关讨论

您可以这样使用indexOf方法：

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

Note: You'll need to shim it for IE8 and below

1
2
3
4
5
6
7
var array = [1,2,3,4]
var item = 3

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

console.log(array)

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
*/

使之成为全球性的-

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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及以下-

1
2
3
4
5
6
7
8
9
10
11
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;
    };
}
相关讨论

一条船就行了，

1
2
3
4
5
6
7
8
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中的filter函数。IE9及更高版本支持它。

它的作用(从文档链接)

filter() calls a provided callback function once for each element in an array, and constructs a new array of all the values for which callback returns a value that coerces to true. callback is invoked only for indexes of the array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values. Array elements which do not pass the callback test are simply skipped, and are not included in the new array.

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

基本上，与for in构造(afaik)相比，filter是一种看起来更好(并且可以链接)的方便方法。

相关讨论

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

例如，有了它：

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

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

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

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

它减少了您编写的代码。

相关讨论

以这种方式查看：

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

在函数中：

1
2
3
4
5
6
7
8
9
10
function removeItem(array, item){
    for(var i in array){
        if(array[i]==item){
            array.splice(i,1);
            break;
        }
    }
}

removeItem(array, 'seven');
相关讨论

下面是一个使用jquery的inarray函数的版本：

1
2
3
4
var index = $.inArray(item, array);
if (index != -1) {
    array.splice(index, 1);
}
相关讨论

1
2
3
4
5
6
var index = array.indexOf('item');

if(index!=-1){

   array.splice(index, 1);
}

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

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

第一：

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

第二(ES6)：

1
arr = arr.filter(e => e !== '3')
相关讨论

你想要的是过滤

https://developer.mozilla.org/en-us/docs/web/javascript/reference/global_objects/array/filter

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

1
2
3
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

相关讨论

既然没有一个漂亮的，这里有一个简单的、可重用的ES6函数。

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

用途：

1
2
const items = ['orange', 'purple', 'orange', 'brown', 'red', 'orange']
removeArrayItem(items, 'orange')
相关讨论

如果数组中有唯一的值，并且顺序无关紧要，则可以使用set，它具有delete：

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

简单地

1
2
3
4
5
6
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);
 }
相关讨论

ES6方式。

1
const commentsWithoutDeletedArray = commentsArray.filter(comment => comment.Id !== commentId);
相关讨论

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

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

或者你想用香草JS

1
arr = arr.filter(function(value) { return value !== 'seven' });
相关讨论

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

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

我用jquery进行了大量的提升，但是如果你想成为本地人，你就有了这个想法。

相关讨论

一个非常干净的解决方案可以在所有浏览器中运行，并且不需要任何框架，它只需设计一个新的数组，返回它，而不需要删除任何项：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
 * @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;
}
相关讨论

最简单的解决方案是：

array—用于删除某些元素值的数组；移除值-移除元素；

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

更简单：

1
array.filter(arrayItem => arrayItem !== valueForRemove);
相关讨论

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

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

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

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

任何健全的javascript环境都会为这些对象创建一个可搜索的索引，这样无论对象有多少属性，您都可以快速地将一个键转换为一个值。

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

相关讨论

您可以使用lodash _.remove功能来实现这一点。

1
2
3
4
5
6
var array = ['three', 'seven', 'eleven'];
var evens = _.remove(array, function(e) {
  return e !== 'seven';
});

console.log(evens);
1
<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js">

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

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

技巧是从头到尾遍历数组，这样在删除元素时就不会弄乱索引。

1
2
3
4
5
6
7
8
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现在是["红"、"黑"、"白"]

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

1
2
3
4
5
6
7
    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]

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

1
2
3
4
5
6
7
8
9
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]
相关讨论

您可以从lodash使用without或pull：

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

无损移除：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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;
}

请不要将该变量与delete一起使用-它会在数组中留下一个洞，因为它不会在删除项后重新索引元素。

1
2
3
4
5
6
7
8
9
10
> 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' ]

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

1
2
3
4
5
6
7
8
9
function cleanArrayOfSpecificTerms(array,unwantedTermsArray) {
  $.each(unwantedTermsArray, function( index, value ) {
    var index = array.indexOf(value);
    if (index > -1) {
      array.splice(index, 1);        
    }
  });
  return array;
}

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

1
2
3
4
var notInclude = ['Not','No','First','Last','Prior','Next', 'dogs','cats'];
var splitTerms = ["call","log","dogs","cats","topic","change","pricing"];

cleanArrayOfSpecificTerms(splitTerms,notInclude)
1
2
3
4
5
6
7
8
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]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//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;
}

使用示例

1
2
3
4
5
6
7
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]]

coffeescript+jquery变量：

1
2
3
4
5
6
7
8
arrayRemoveItemByValue = (arr,value) ->
  r=$.inArray(value, arr)
  unless r==-1
    arr.splice(r,1)
  # return
  arr

console.log arrayRemoveItemByValue(['2','1','3'],'3')

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

另一个变化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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循环。

我尝试使用上面jbaron中的函数方法，但发现我需要保留原始数组的完整性以供以后使用，并创建一个类似以下的新数组：

1
var newArray = referenceArray;

显然是通过引用而不是值创建的，因为当我从newarray中移除元素时，referencearray也将其移除。所以我决定每次都创建一个这样的新数组：

1
2
3
4
5
6
7
function newArrRemoveItem(array, item, newArray){
    for(var i = 0; i < array.length; i++) {
        if(array[i]!=item){
            newArray.push(array[i]);
        }
    }
}

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

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

现在VesselArr保持完整，而每次执行上述代码时，OtherVesselArr数组都包含除最新的VesselID元素之外的所有元素。

1
2
3
4
5
6
7
8
var remove = function(array, value) {
    var index = null;

    while ((index = array.indexOf(value)) !== -1)
        array.splice(index, 1);

    return array;
};

您可以使用lodash pull函数

1
2
3
var ary = ['three', 'seven', 'eleven'];
_.pull(ary, 'seven'); // ['three', 'eleven']
console.log(ary)
1
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.6.1/lodash.js">

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

1
2
3
4
5
6
7
8
 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
相关讨论

//感谢Marcoci的建议编辑

试试这个：

1
2
3
4
5
6
7
8
9
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']

希望这对你有帮助

相关讨论