查找index使用indexOf,然后删除该索引splice.

组合法通过删除现有元素和/或添加新元素来改变数组的内容。

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) { // only splice array when item is found
  array.splice(index, 1); // 2nd parameter means remove one item only
}

// array = [2, 9]
console.log(array); 

第二个参数的第二个参数splice是要删除的元素数。请注意splice修改现有数组,并返回含有已删除元素的新数组。

由于完整性的原因,此处为函数。第一个函数只删除一个单一事件(即删除第一个匹配5调自[2,5,9,1,5,8,5]),而第二个函数删除所有事件:

function removeItemOnce(arr, value) {
  var index = arr.indexOf(value);
  if (index > -1) {
    arr.splice(index, 1);
  }
  return arr;
}

function removeItemAll(arr, value) {
  var i = 0;
  while (i < arr.length) {
    if (arr[i] === value) {
      arr.splice(i, 1);
    } else {
      ++i;
    }
  }
  return arr;
}
// Usage
console.log(removeItemOnce([2,5,9,1,5,8,5], 5))
console.log(removeItemAll([2,5,9,1,5,8,5], 5))

在类型Script中,这些函数可用类型参数保持类型安全:

function removeItem<T>(arr: Array<T>, value: T): Array<T> { 
  const index = arr.indexOf(value);
  if (index > -1) {
    arr.splice(index, 1);
  }
  return arr;
}

2021年更新

您的问题是如何从数组中删除一个特定项目。 您在具体项目中指的是一个数字, 例如 。 从数组中删除数字 5 。 据我了解, 您正在寻找类似 :

// PSEUDOCODE, SCROLL FOR COPY-PASTE CODE
[1,2,3,4,5,6,8,5].remove(5) // result: [1,2,3,4,6,8]

至于2021年,实现该目标的最佳途径是使用数组过滤功能:

const input = [1,2,3,4,5,6,8,5];
const removeNumber = 5;
const result = input.filter(
    item => item != removeNumber
);

以上例子的使用数组. prototype. filter函数。它会对所有数组项目进行迭代,并且只返回符合箭头函数结果,旧阵列保持不变,而一个新的阵列则被称为result包含不等于 5 的所有项目。您可以自己测试它在线在线.

你可以直观地看到数组. prototype. filter像这样 :

考虑考虑的考虑

守则质量

Array.prototype.filter在此情况下,这是消除数字的最容易读懂的方法,对错误几乎没有留有余地,并使用联署材料的核心功能。

为什么不array.prototype.map?

Array.prototype.map有时被视作一种替代array.prototype.filter对于此用途的话, 使用它。 但不应该使用它。 原因是数组. prototype. filter概念上用于过滤过滤项目能够满足箭头函数(精确我们需要的)的箭头功能,而数组. prototype.map用于变换项。由于在对项目进行循环时,我们不更改项目,使用的适当功能是array.prototype.filter.

支助支助支助支助支助支助支助支助支助支助支助支助支助支助支助支助支助支助

截至今天(11.4.2022)94.08%的互联网用户'浏览器支持iE6 - 8 不支持它。 所以, 如果您的使用案例需要支持这些浏览器, 将会有一个不错的多元填充克里斯·费迪南蒂的作品

业绩 业绩业绩 业绩业绩

Array.prototype.filter对于大多数使用过的个案来说是巨大的。然而,如果您在寻找先进数据处理的性能改进,您可以探索一些高级数据处理的性能改进。其它选项像使用纯for。另一个伟大的选项是重新思考您正在处理的数组是否真的必须如此大。这可能是一个信号,即 JavaScript 应该从数据源获得一个减少的数组来进行处理。

不同可能性的基准:https://jsben.ch/C5MXz

删除某一要素或随后的元素,Array.spolice ()方法运作良好。

组合法通过删除或替换现有元素和(或)添加新元素来改变数组的内容,并返回被删除的项目。

语法: 数组. spice( index, deleteCount, items 1,...,..., itemsX)

给index休息辩论是强制性的,休息辩论是任择的。

例如:

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2,1);
console.log(arr);
// [1, 2, 4, 5, 6]

注: Array.spolice ()如果您知道要删除的元素的索引, 可以使用该方法。 但我们可能还会有以下几个例子:

1. 如果您想要删除仅最后一个元素, 您可以使用Array.pop ()

2. 如果您想要删除仅第一个元素, 您可以使用矩阵. trip ()

3. 如果您只知道元素, 而不知道元素的位置(或索引), 并且想要删除所有匹配元素Array. filter ()方法 :

   let arr = [1, 2, 1, 3, 4, 1, 5, 1];
   
   let newArr = arr.filter(function(val){
       return val !== 1;
   });
   //newArr => [2, 3, 4, 5]
   

   或者通过使用复数()方法作为:

   let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
       for (let i = 0; i < arr.length-1; i++) {
          if ( arr[i] === 11) {
            arr.splice(i, 1);
          }
       }
       console.log(arr);
       // [1, 2, 3, 4, 5, 6]
   

   或者假设我们想要删除del从数组arr:

   let arr = [1, 2, 3, 4, 5, 6];
   let del = 4;
   if (arr.indexOf(4) >= 0) {
       arr.splice(arr.indexOf(4), 1)
   }
   

   或

   let del = 4;
   for(var i = arr.length - 1; i >= 0; i--) {
       if(arr[i] === del) {
          arr.splice(i, 1);
       }
   }
   

4. 如果您只知道元素, 而不知道元素的位置( 或索引) , 并且想要使用 复数 () 方法删除第一个匹配元素 :

   let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
   
   for (let i = 0; i < arr.length-1; i++) {
     if ( arr[i] === 11) {
       arr.splice(i, 1);
       break;
     }
   }
   console.log(arr);
   // [1, 11, 2, 11, 3, 4, 5, 11, 6, 11]
   

您可以为此创建一个原型。只需通过数组元素和您想要从数组元素中删除的值:

Array.prototype.removeItem = function(array,val) {
    array.forEach((arrayItem,index) => {
        if (arrayItem == val) {
            array.splice(index, 1);
        }
    });
    return array;
}
var DummyArray = [1, 2, 3, 4, 5, 6];
console.log(DummyArray.removeItem(DummyArray, 3));

我测试过splice和filter查看哪个速度更快 :

let someArr = [...Array(99999).keys()] 

console.time('filter')
someArr.filter(x => x !== 6666)
console.timeEnd('filter')

console.time('splice by indexOf')
someArr.splice(someArr.indexOf(6666), 1)
console.timeEnd('splice by indexOf')

在我的机器上splice更快。这有道理,因为splice仅编辑现有的数组,而filter创建新数组。

尽管如此,filter逻辑上更清洁(容易阅读),更适合使用不可改变状态的编码风格。所以由你决定是否进行这种权衡决定。

通过传递其值来删除项目 --

const remove=(value)=>{
    myArray = myArray.filter(element=>element !=value);

}

将项目通过索引编号删除 -

  const removeFrom=(index)=>{
    myArray = myArray.filter((_, i)=>{
        return i!==index
    })
}