使用.indexof () 和.spolice () - 可变模式

这里有两种情况:

1. 我们知道指数

const drinks = [ 'Tea', 'Coffee', 'Milk'];
const id = 1;
const removedDrink = drinks.splice(id,  1);
console.log(removedDrink)

2. 我们不知道指数,

   const drinks =  ['Tea','Coffee', 'Milk'];
   const id = drinks.indexOf('Coffee'); // 1
   const removedDrink = drinks.splice(id,  1);
   // ["Coffee"]
   console.log(removedDrink);
   // ["Tea", "Milk"]
   console.log(drinks);

使用. filter () - 不可变模式

你可以想到的最好方式是 — — 而不是“删除”该项目,而是“创造”一个新的阵列,只是不包含该项目。 所以我们必须找到它,完全省略它。

const drinks = ['Tea','Coffee', 'Milk'];
const id = 'Coffee';
const idx = drinks.indexOf(id);
const removedDrink = drinks[idx];
const filteredDrinks = drinks.filter((drink, index) => drink == removedDrink);

console.log("Filtered Drinks Array:"+ filteredDrinks);
console.log("Original Drinks Array:"+ drinks);

缩略复数()通过删除或替换现有元素和(或)添加新元素来改变数组的内容。

数组。 spice( 开始 [, 删除 [, 删除 [, 项1 [, 项2 [, . ] ] ] ]

开始

开始更改数组的索引( 与源值为 0 ) 。 如果数组的长度大于数组的长度, 则实际起始指数将设置为数组的长度。 如果为负, 则开始从数组结尾处( 与源值为-1) 的许多元素, 如果绝对值大于数组的长度, 则将设置为 0 。

删除“ 计算” 选项@ action

表示要删除的旧数组元素数的整数。

如果删除“计算”被省略,或者如果其值大于数组。 长度 - 开始( 即如果它大于数组中剩下的元素数量, 从开始) , 那么从开始到数组结尾的所有元素都将删除。 如果删除“ 计算” 0 或“ 负” , 则不删除任何元素。 在这种情况下, 您应该至少指定一个新元素( 见下文) 。

第1项,第2项,...可选

要添加到数组的元素, 从起始索引开始。 如果您不指定任何元素, 组合() 只会从数组中删除元素 。

如需更多参考,请通过:

Array. prototype.spice ()

最简单的方法可能是使用过滤功能。例如:

let array = ["hello", "world"]
let newarray = array.filter(item => item !== "hello");
console.log(newarray);
// ["world"]

删除单个元素

function removeSingle(array, element) {
    const index = array.indexOf(element)
    if (index >= 0) {
        array.splice(index, 1)
    }
}

删除多个元素, 位置内

这对于确保算法在O(N)时间运行更为复杂。

function removeAll(array, element) {
    let newLength = 0
    for (const elem of array) {
        if (elem !== number) {
            array[newLength++] = elem
        }
    }
    array.length = newLength
}

删除多个元素,创建新对象

array.filter(elem => elem !== number)

多可惜,您有数组整数,而不是键是这些整数的字符串等量的对象。

我看过很多这样的答案, 在我看来,它们似乎都使用了“粗力 ” ( 粗力 ) 。 我还没有检查每个答案, 如果不是这样的话, 请道歉。 对于一个小的阵列来说,这很好, 但如果你有千个整数呢?

纠正我,如果我错了, 但我们不能假设,在key => valueJavaScript 对象的地图, 即 JavaScript 对象的地图, 关键检索机制可以被假定为高度工程设计和优化吗? (NB:如果一些超级专家告诉我情况并非如此, 我可以建议使用ECMAScript 6's映图类相反,这当然会是) )。

我只是建议,在某些情况下,最好的解决办法可能是 将你的阵列转换成一个物体... 问题当然是,你可能会重复整数值。我建议把这些放在桶中作为“价值”的一部分。key => value。 (NB: 如果您确定您没有重复的数组元素, 这样可以简单得多 : 值“ 和” 键, 然后直接去Object.values(...)返回修改后的阵列)。

所以,你可以做到这一点:

const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
const f =    function( acc, val, currIndex ){
    // We have not seen this value before: make a bucket... NB: although val's typeof is 'number',
    // there is seamless equivalence between the object key (always string)
    // and this variable val.
    ! ( val in acc ) ? acc[ val ] = []: 0;
    // Drop another array index in the bucket
    acc[ val ].push( currIndex );
    return acc;
}
const myIntsMapObj = arr.reduce( f, {});

console.log( myIntsMapObj );

产出:

对象 [ < 1 空位, 数组]1, 阵列[2], 阵列1, 矩阵, 阵列1,<5个空位,46个以上...]

然后很容易删除所有55个数字。

delete myIntsMapObj[ 55 ]; // Again, although keys are strings this works

你不必全部删除: 指数值按外观被挤进桶里, 所以(例如):

myIntsMapObj[ 55 ].shift(); // And
myIntsMapObj[ 55 ].pop();

将分别删除第一次和最后一次发生的情况。 您可以很容易地计算发生频率, 将一个桶的内装物转移到另一个桶等, 将所有55个都替换为3个 。

获取已修改的int从您的“ bucket 对象” 的数组数组中略微涉及到“ bucket 对象” ,但数量不多:每个桶都包含( 最初数组) 所代表的数值的索引( 以原始数组表示) 。string关键值 。 这些桶的每个值也是独特的(每个都是独一的)指数指数值原数组中原始数组 : 因此, 您可以在新对象中将其转换为键, 以“ 整数字符串键” 中的( 真实) 整数作为值... 然后排序键然后去Object.values( ... ).

这听起来很牵扯,很费时... 但显然一切都取决于环境 和理想的用法。我的理解是 JavaScript 的所有版本和背景 只能用一条线运作, 这条线不会“放手 ” , 所以可能会有一些可怕的堵塞 与“强力 ” 方法: 原因不在于它。indexOf选项,但多次重复slice/splice行动。

Addendum如果你是确定这对你的使用来说太过于工程化了 当然最简单的"强力"方法就是

const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )

(是的,其他答案已发现)Array.prototype.filter...)

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