如何按值从数组中删除项？-Java 学习之路

696

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

给定一个数组：

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

我想做的事情如下：

removeItem('seven', ary);

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

30 回答

ES6的方式 .

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

回复于 2024-04-29T01:37:28+08:00

403

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

if(index!=-1){

   array.splice(index, 1);
}

回复于 2024-04-29T01:37:28+08:00

您可以使用 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>

回复于 2024-04-29T01:37:28+08:00

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

回复于 2024-04-29T01:37:28+08:00

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]

回复于 2024-04-29T01:37:28+08:00

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

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

回复于 2024-04-29T01:37:28+08:00

1236

非破坏性清除：

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

回复于 2024-04-29T01:37:28+08:00

25
单行将会这样做，
```
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及更高版本中得到支持 .

它的作用（来自doc链接）

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

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

基本上，过滤器是一种方便的方法，与 for in 构造（AFAIK）相比，看起来更好（并且是可链接的） .
回复于 2024-04-29T01:37:28+08:00
2
这里's a version that uses jQuery' s inArray function：
```
var index = $.inArray(item, array);
if (index != -1) {
    array.splice(index, 1);
}
```
回复于 2024-04-29T01:37:28+08:00
0
我尝试使用jbaron上面的函数方法，但发现我需要保持原始数组的完整性以便以后使用，并创建一个新的数组，如下所示：
```
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元素以外的所有内容 .
回复于 2024-04-29T01:37:28+08:00

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

Example of using

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

回复于 2024-04-29T01:37:28+08:00

283

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

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

用法：

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

回复于 2024-04-29T01:37:28+08:00

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

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

或许你想要使用香草JS

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

回复于 2024-04-29T01:37:28+08:00

看看这个方式：

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

回复于 2024-04-29T01:37:28+08:00

127

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

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

回复于 2024-04-29T01:37:28+08:00

Simply

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

回复于 2024-04-29T01:37:28+08:00

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

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

回复于 2024-04-29T01:37:28+08:00

1
您可以使用 without 中的 without 或 pull ：
```
const _ = require('lodash');
_.without([1, 2, 3, 2], 2); // -> [1, 3]
```
回复于 2024-04-29T01:37:28+08:00

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

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)

回复于 2024-04-29T01:37:28+08:00

var remove = function(array, value) {
    var index = null;

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

    return array;
};

回复于 2024-04-29T01:37:28+08:00

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]

回复于 2024-04-29T01:37:28+08:00

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

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

基本上，您可以使用对象为数组创建索引，如下所示：
```
var index={'three':0, 'seven':1, 'eleven':2};
```
任何理智的JavaScript环境都会为这些对象创建一个可搜索的索引，这样无论对象有多少属性，您都可以快速将键转换为值 .

这只是基本方法，根据您的需要，您可以组合多个对象和/或数组，以便为不同的属性快速搜索相同的数据 . 如果您指定了确切的需求，我可以建议更具体的数据结构 .
回复于 2024-04-29T01:37:28+08:00

您可以像这样使用indexOf method：

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)

回复于 2024-04-29T01:37:28+08:00

7
你所追求的是过滤器

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
回复于 2024-04-29T01:37:28+08:00
0
从数组中删除所有匹配的元素（而不是仅仅是第一个，这似乎是最常见的答案）：
```
while ($.inArray(item, array) > -1) {
    array.splice( $.inArray(item, array), 1 );
}
```
我使用jQuery进行繁重的工作，但如果你想成为原生人，你就会明白这一点 .
回复于 2024-04-29T01:37:28+08:00

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

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]

回复于 2024-04-29T01:37:28+08:00

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

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

回复于 2024-04-29T01:37:28+08:00

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

例如，有了这个：
```
var result = _.without(['three','seven','eleven'], 'seven');
```
result 将 ['three','eleven'] .

在您的情况下，您必须编写的代码是：
```
ary = _.without(ary, 'seven')
```
它减少了您编写的代码 .
回复于 2024-04-29T01:37:28+08:00

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

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

回复于 2024-04-29T01:37:28+08:00

请不要将变量与 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' ]

回复于 2024-04-29T01:37:28+08:00

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

30 回答

相关问题