如何从javascript中的数组中删除特定元素？


How do I remove a particular element from an array in JavaScript?

我有一个数字数组，我正在使用.push()方法向它添加元素。

有没有一种简单的方法可以从数组中删除特定的元素？类似于array.remove(number);的东西。

我必须使用核心的javascript——不允许使用任何框架。

相关讨论

阵列index找到你想删除元素，然后删除，以splice指数。

The splice() method changes the contents of an array by removing
existing elements and/or adding new elements.

1
2
3
4
5
6
7
8
var array = [2, 5, 9];
console.log(array)
var index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}
// array = [2, 9]
console.log(array);

第二个参数的元素的数量splice)是消除。请注意，splicemodifies原位阵列阵列和收益的新的元素，含已被删除。

相关讨论

我不知道你是expecting array.remove(int)CT表现。有三种可能，我能想到你可能想要的。

一种消除在一个数组元素的索引i：

1
array.splice(i, 1);

如果你想删除一元与阵列：从价值number

1
2
3
4
5
for(var i = array.length - 1; i >= 0; i--) {
    if(array[i] === number) {
       array.splice(i, 1);
    }
}

如果你只是想使该元素在索引i不再存在，但你真的想在其他元素的变化指标。

1
delete array[i];
相关讨论

2016年10月编辑

  • 做到简单、直观、明确(https://en.wikipedia.org/wiki/occam%27s_razor)
  • 不可变(原始数组保持不变)
  • 如果您的浏览器不支持标准JS函数，可以使用它们-使用polyfill

在此代码示例中，我使用"array.filter(…)"函数从数组中删除不需要的项，此函数不会更改原始数组并创建新的数组。如果您的浏览器不支持此功能(例如9版之前的IE或1.5版之前的Firefox)，请考虑使用Mozilla的过滤器polyfill。

移除项目(ECMA-262第5版代码又称OldStyle JS)

1
2
3
4
5
6
7
8
9
10
var value = 3

var arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(function(item) {
    return item !== value
})

console.log(arr)
// [ 1, 2, 4, 5 ]

移除项目(ES2015代码)

1
2
3
4
5
6
7
8
let value = 3

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => item !== value)

console.log(arr)
// [ 1, 2, 4, 5 ]

重要的ES2015"()=>"箭头函数语法在IE中根本不受支持，45版之前的Chrome，22版之前的Firefox，10版之前的Safari。要在旧浏览器中使用ES2015语法，可以使用babeljs

删除多个项目(ES2016代码)

此方法的另一个优点是可以删除多个项

1
2
3
4
5
6
7
8
9
let forDeletion = [2, 3, 5]

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => !forDeletion.includes(item))
// !!! Read below about array.includes(...) support !!!

console.log(arr)
// [ 1, 4 ]

重要的是，IE根本不支持"array.includes(…)"函数，47版之前的Chrome，43版之前的Firefox，9版之前的Safari，14版之前的Edge，所以这里是来自Mozilla的polyfill

删除多个项目(尖端实验性javascript ES2018？)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// array-lib.js

export function remove(...forDeletion) {
    return this.filter(item => !forDeletion.includes(item))
}

// main.js

import { remove } from './array-lib.js'

let arr = [1, 2, 3, 4, 5, 3]

// :: This-Binding Syntax Proposal
// using"remove" function as"virtual method"
// without extending Array.prototype
arr = arr::remove(2, 3, 5)

console.log(arr)
// [ 1, 4 ]

你自己试试吧，宝贝们：)

参考文献

  • array.prototype.includes包括
  • 此绑定语法建议
  • 功能成分
相关讨论

取决于你是否想保持一点或不空。

如果你想删除一个空的插槽，是精细。

1
delete array[ index ];

如果你不，你应该使用拼接方法

1
array.splice( index, 1 );

如果你需要这个项目的价值，你可以只返回数组的元素店：

1
var value = array.splice( index, 1 )[0];

你想它在案例中，你可以使用一些命令，一个或array.pop()是最后一array.shift()for the First(和返回的项目的价值都太)。

如果你不知道该指数的项目，你可以使用array.indexOf( item )让它(在一个或if()让项目中得到所有他们while())。该指数是指array.indexOf( item )收益或1如果没有发现。& nbsp；

相关讨论

一位朋友在Internet Explorer 8中遇到问题，他向我展示了他的所作所为。我告诉他是错的，他告诉我他在这里得到了答案。当前的热门答案在所有浏览器(例如Internet Explorer 8)中都不起作用，它只会删除第一次出现的项目。

从数组中删除所有实例

1
2
3
4
5
6
7
function remove(arr, item) {
    for (var i = arr.length; i--;) {
        if (arr[i] === item) {
            arr.splice(i, 1);
        }
    }
}

它向后循环数组(因为索引和长度会随着项的移除而改变)，如果找到了项，则会移除它。它适用于所有浏览器。

相关讨论

有两个主要的方法：

  • anArray.splice(index, 1);splice()：

  • 删除：delete anArray[index];

    • 当你被介绍时使用删除一个数组。这是一个好的代码对象的属性(但不只是好的阵列。这是最好使用的是splice阵列。

    当你使用这把记忆中的你是一delete阵列可以得到错误的结果是anArray.length。在其他的话，将删除的delete元而不是更新属性值的长度。

    你也可以期待有一个孔中，利用指数后删除，例如你可以有1,3,4,8,9,11端跟踪指数的使用和长度，这是以前删除。这一案例中，所有的索引for环会崩溃，是因为指标的时间序列。

    如果你被迫使用delete的一些原因，你应该使用时，你需要for each通环的环阵列。事实上的，总是避免使用索引是循环的，如果可能的。这样的代码将是更健壮和易用不到索引的问题。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    Array.prototype.remByVal = function(val) {
        for (var i = 0; i < this.length; i++) {
            if (this[i] === val) {
                this.splice(i, 1);
                i--;
            }
        }
        return this;
    }
    //Call like
    [1, 2, 3, 4].remByVal(3);

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    Array.prototype.remByVal = function(val) {
        for (var i = 0; i < this.length; i++) {
            if (this[i] === val) {
                this.splice(i, 1);
                i--;
            }
        }
        return this;
    }

    var rooms = ['hello', 'something']

    rooms = rooms.remByVal('hello')

    console.log(rooms)

    相关讨论

    不需要使用indexOf或splice。但是，如果只想删除元素的一个匹配项，那么它的性能会更好。

    查找并移动(移动)：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    function move(arr, val) {
      var j = 0;
      for (var i = 0, l = arr.length; i < l; i++) {
        if (arr[i] !== val) {
          arr[j++] = arr[i];
        }
      }
      arr.length = j;
    }

    使用indexOf和splice(indexof)：

    1
    2
    3
    4
    5
    6
    function indexof(arr, val) {
      var i;
      while ((i = arr.indexOf(val)) != -1) {
        arr.splice(i, 1);
      }
    }

    仅使用splice(拼接)：

    1
    2
    3
    4
    5
    6
    7
    function splice(arr, val) {
      for (var i = arr.length; i--;) {
        if (arr[i] === val) {
          arr.splice(i, 1);
        }
      }
    }

    具有1000个元素的数组在nodejs上的运行时间(平均超过10000次运行)：

    indexof大约比move慢10倍。即使通过删除拼接中对indexOf的调用而得到改进，它的性能也比move差得多。

    1
    2
    3
    4
    5
    6
    7
    8
    Remove all occurrences:
        move 0.0048 ms
        indexof 0.0463 ms
        splice 0.0359 ms

    Remove first occurrence:
        move_one 0.0041 ms
        indexof_one 0.0021 ms
    相关讨论

    太旧，无法答复，但它可能通过提供谓词而不是值来帮助某人。

    注意：它将更新给定的数组，并返回受影响的行。

    用法

    1
    2
    3
    var removed = helper.removeOne(arr, row => row.id === 5 );

    var removed = helper.remove(arr, row => row.name.startsWith('BMW'));

    定义

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    var helper = {

        // Remove and return the first occurrence    

        removeOne: function(array, predicate) {
            for (var i = 0; i < array.length; i++) {
                if (predicate(array[i])) {
                    return array.splice(i, 1);
                }
            }
        },

        // Remove and return all occurrences  

        remove: function(array, predicate) {
            var removed = [];

            for (var i = 0; i < array.length;) {

                if (predicate(array[i])) {
                    removed.push(array.splice(i, 1));
                    continue;
                }

                i++;                
            }

            return removed;
        }
    };
    相关讨论

    John Resig发布了一个良好的实施方案：

    1
    2
    3
    4
    5
    6
    // Array Remove - By John Resig (MIT Licensed)
    Array.prototype.remove = function(from, to) {
      var rest = this.slice((to || from) + 1 || this.length);
      this.length = from < 0 ? this.length + from : from;
      return this.push.apply(this, rest);
    };

    如果不想扩展全局对象，可以执行以下操作：

    1
    2
    3
    4
    5
    6
    // Array Remove - By John Resig (MIT Licensed)
    Array.remove = function(array, from, to) {
        var rest = array.slice((to || from) + 1 || array.length);
        array.length = from < 0 ? array.length + from : from;
        return array.push.apply(array, rest);
    };

    但我发布这篇文章的主要原因是警告用户不要使用该页面(2007年12月14日)评论中建议的替代实施方案：

    1
    2
    3
    4
    Array.prototype.remove = function(from, to){
      this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to);
      return this.length;
    };

    起初它似乎工作得很好，但经过一个痛苦的过程，我发现在试图删除数组中的第二个到最后一个元素时失败了。例如，如果您有一个10元素数组，并尝试用它删除第9个元素：

    1
    myArray.remove(8);

    最后是一个8元素数组。不知道为什么，但我确认了John最初的实现没有这个问题。

    相关讨论

    可以使用underline.js来解决多个浏览器的问题。它在构建浏览器方法中使用(如果存在)。如果它们不存在，就像以前的Internet Explorer版本一样，它使用自己的自定义方法。

    从数组(从网站)中删除元素的简单示例：

    1
    _.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]

    使用过滤方法可以很容易地做到这一点：

    1
    2
    3
    4
    function remove(arrOriginal, elementToRemove){
        return arrOriginal.filter(function(el){return el !== elementToRemove});
    }
    console.log( remove([1, 2, 1, 0, 3, 1, 4], 1) );

    这将从数组中移除所有元素，并且比slice和indexof的组合工作得更快

    相关讨论

    如果你要删除的位置，与新的数组，你可以删除，永远删除的具体元素和滤波器输出的阵列。它可能需要一个扩展的阵列对象浏览器这是Don’t实现滤波器的方法，但它更容易在长期的，因为这是所有你的。

    1
    2
    3
    var my_array = [1,2,3,4,5,6];
    delete my_array[4];
    console.log(my_array.filter(function(a){return typeof a !== 'undefined';}));

    要显示[1, 2, 3, 4, 6]

    您可以使用ES6。

    1
    2
    var array=['1','2','3','4','5','6']
    var index = array.filter((value)=>value!='3');

    输出：

    1
    ["1","2","4","5","6"]
    相关讨论

    该代码检查。它的工作在每一个主要的浏览器。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    remove_item = function (arr, value) {
        var b = '';
        for (b in arr) {
            if (arr[b] === value) {
                arr.splice(b, 1);
                break;
            }
        }
        return arr;
    }

    调用这个函数

    1
    remove_item(array,value);
    相关讨论

    您可以使用lodash uupull(mutate array)、pullat(mutate array)或不使用(不改变array)的。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    var array1 = ['a', 'b', 'c', 'd']
    _.pull(array1, 'c')
    console.log(array1) // ['a', 'b', 'd']

    var array2 = ['e', 'f', 'g', 'h']
    _.pullAt(array2, 0)
    console.log(array2) // ['f', 'g', 'h']

    var array3 = ['i', 'j', 'k', 'l']
    var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
    console.log(array3) // ['i', 'j', 'k', 'l']
    相关讨论

    好的，例如，您有下面的数组：

    1
    var num = [1, 2, 3, 4, 5];

    我们要删除4号，您只需执行以下代码：

    1
    num.splice(num.indexOf(4), 1); //num will be [1, 2, 3, 5];

    如果重用此函数，则编写一个可重用函数，该函数将附加到本机数组函数，如下所示：

    1
    2
    3
    4
    5
    Array.prototype.remove = Array.prototype.remove || function(x) {
      const i = this.indexOf(x);
      if(i===-1) return;
      this.splice(i, 1); //num.remove(5) === [1, 2, 3];
    }

    但是，如果您使用下面的数组，而不是数组中只有几个[5]s呢？

    1
    var num = [5, 6, 5, 4, 5, 1, 5];

    我们需要一个循环来检查它们，但是更简单、更有效的方法是使用内置的javascript函数，因此我们编写了一个函数，它使用下面这样的过滤器：

    1
    2
    const _removeValue = (arr, x) => arr.filter(n => n!==x);
    //_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) //return [1, 2, 3, 4, 6]

    还有一些第三方库可以帮助您做到这一点，如lodash或underline，有关更多信息，请查看lodash u.pull、u.pull at或u.without。

    相关讨论

    我对javascript非常陌生，需要这个功能。我只是写了：

    1
    2
    3
    4
    5
    function removeFromArray(array, item, index) {
      while((index = array.indexOf(item)) > -1) {
        array.splice(index, 1);
      }
    }

    当我想使用它时：

    设置一些虚拟数据var dummomobj=name:"喵

    无突变的ES6：(2016年10月)

    1
    2
    3
    4
    5
    const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];

    然后：

    1
    removeByIndex([33,22,11,44],1) //=> [33,11,44]
    相关讨论

    更新：这是推荐的方法。如果你无法使用ECMAScript(以前称为es6 2015年)。如果你可以使用它在其他的答案，提供多neater实现。

    这将解决你的问题。在这里，也deletes所有事件需要一个参数化的而不是(或指定的值(1)。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    Array.prototype.destroy = function(obj){
        // Return null if no objects were found and removed
        var destroyed = null;

        for(var i = 0; i < this.length; i++){

            // Use while-loop to find adjacent equal objects
            while(this[i] === obj){

                // Remove this[i] and store it within destroyed
                destroyed = this.splice(i, 1)[0];
            }
        }

        return destroyed;
    }

    用法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    var x = [1, 2, 3, 3, true, false, undefined, false];

    x.destroy(3);         // => 3
    x.destroy(false);     // => false
    x;                    // => [1, 2, true, undefined]

    x.destroy(true);      // => true
    x.destroy(undefined); // => undefined
    x;                    // => [1, 2]

    x.destroy(3);         // => null
    x;                    // => [1, 2]

    如果数组中有复杂的对象，可以使用过滤器吗？在$.in array或array.splice不易使用的情况下。尤其是如果对象在数组中可能很浅。

    例如，如果您有一个具有ID字段的对象，并且希望从数组中删除该对象：

    1
    2
    3
    this.array = this.array.filter(function(element, i) {
        return element.id !== idToRemove;
    });
    相关讨论

    下面是使用javascript从数组中删除项的几种方法。

    所描述的所有方法都不会改变原始数组，而是创建一个新的数组。

    如果你知道一个项目的索引

    假设您有一个数组，并且您想要删除位置i中的一个项。

    一种方法是使用slice()：

    1
    2
    3
    4
    5
    const items = ['a', 'b', 'c', 'd', 'e', 'f']
    const i = 3
    const filteredItems = items.slice(0, i).concat(items.slice(i+1, items.length))

    console.log(filteredItems)

    slice()用它接收的索引创建一个新数组。我们只需创建一个新的数组，从开始到要删除的索引，然后将另一个数组从第一个位置连接到数组的末尾。

    如果你知道价值

    在这种情况下，一个好的选择是使用filter()，它提供了一种更具声明性的方法：

    1
    2
    3
    4
    5
    const items = ['a', 'b', 'c', 'd', 'e', 'f']
    const valueToRemove = 'c'
    const filteredItems = items.filter(item => item !== valueToRemove)

    console.log(filteredItems)

    这将使用ES6箭头功能。您可以使用传统功能来支持较旧的浏览器：

    1
    2
    3
    4
    5
    6
    7
    const items = ['a', 'b', 'c', 'd', 'e', 'f']
    const valueToRemove = 'c'
    const filteredItems = items.filter(function(item) {
      return item !== valueToRemove
    })

    console.log(filteredItems)

    或者，您可以使用babel并将es6代码发回es5，使其更易于旧浏览器理解，同时在代码中编写现代的javascript。

    删除多个项目

    如果要删除多个项目而不是单个项目，该怎么办？

    让我们找到最简单的解决方案。

    按指数

    您只需创建一个函数并删除序列中的项：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    const items = ['a', 'b', 'c', 'd', 'e', 'f']

    const removeItem = (items, i) =>
      items.slice(0, i-1).concat(items.slice(i, items.length))

    let filteredItems = removeItem(items, 3)
    filteredItems = removeItem(filteredItems, 5)
    //["a","b","c","d"]

    console.log(filteredItems)

    按价值

    您可以在回调函数中搜索包含内容：

    1
    2
    3
    4
    5
    6
    const items = ['a', 'b', 'c', 'd', 'e', 'f']
    const valuesToRemove = ['c', 'd']
    const filteredItems = items.filter(item => !valuesToRemove.includes(item))
    //&nbsp;["a","b","e","f"]

    console.log(filteredItems)

    避免改变原始数组

    splice()(不要与slice()混淆)改变了原来的数组，应该避免。

    (最初发布在https://flaviocopes.com/how-to-remove-item-from-array/)

    相关讨论

    我想根据ES6回答。假设您有一个如下的数组：

    1
    let arr = [1,2,3,4];

    如果要删除像2这样的特殊索引，请编写以下代码：

    1
    arr.splice(2, 1); //=> arr became [1,2,4]

    但是如果你想删除一个特殊的项目，比如3，你不知道它的索引如下：

    1
    arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

    提示：除非得到空数组，否则请使用箭头函数进行筛选回调。

    相关讨论

    你不应该改变你的数组或者你的数组。因为这违背了函数式编程模式。您可以创建一个新的数组，而不引用您想要使用ES6方法filter更改数据的数组；

    1
    var myArray = [1,2,3,4,5,6];

    假设您想从数组中删除5，您可以这样做。

    1
    myArray = myArray.filter(value => value !== 5);

    这将为您提供一个没有要删除的值的新数组。所以结果是

    1
     [1,2,3,4,6]; // 5 has been removed from this array

    为了进一步了解，您可以阅读array.filter上的MDN文档https://developer.mozilla.org/en-us/docs/web/javascript/reference/global_objects/array/filter

    一种更现代的Ecmascript 2015(以前称为Harmony或ES 6)方法。鉴于：

    1
    2
    const items = [1, 2, 3, 4];
    const index = 2;

    然后：

    1
    items.filter((x, i) => i !== index);

    顺从的：

    1
    [1, 2, 4]

    您可以使用babel和polyfill服务来确保在浏览器中得到很好的支持。

    相关讨论

    我知道已经有很多答案了，但其中许多似乎过于复杂化了问题。这是一种简单的递归方法，可以删除键调用self的所有实例，直到找不到索引为止。是的，它只在使用indexOf的浏览器中工作，但是它很简单，而且很容易被多填充。

    独立功能

    1
    2
    3
    4
    5
    6
    7
    8
    function removeAll(array, key){
        var index = array.indexOf(key);

        if(index === -1) return;

        array.splice(index, 1);
        removeAll(array,key);
    }

    原型方法

    1
    2
    3
    4
    5
    6
    7
    8
    Array.prototype.removeAll = function(key){
        var index = this.indexOf(key);

        if(index === -1) return;

        this.splice(index, 1);
        this.removeAll(key);
    }
    相关讨论

    如果元素有多个实例，可以执行反向循环以确保不会弄乱索引。

    1
    2
    3
    4
    5
    6
    7
    var myElement ="chocolate";
    var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];

    /* Important code */
    for (var i = myArray.length - 1; i >= 0; i--) {
        if (myArray[i] == myElement) myArray.splice(i, 1);
    }

    现场演示

    我还有另一个从数组中移除的好解决方案：

    1
    2
    3
    4
    5
    6
    var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

    const result = words.filter(word => word.length > 6);

    console.log(result);
    // expected output: Array ["exuberant","destruction","present"]

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

    基于所有主要正确的答案，并考虑到建议的最佳实践(特别是不直接使用array.prototype)，我得出了以下代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    function arrayWithout(arr, values) {
      var isArray = function(canBeArray) {
        if (Array.isArray) {
          return Array.isArray(canBeArray);
        }
        return Object.prototype.toString.call(canBeArray) === '[object Array]';
      };

      var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1);
      var arrCopy = arr.slice(0);

      for (var i = arrCopy.length - 1; i >= 0; i--) {
        if (excludedValues.indexOf(arrCopy[i]) > -1) {
          arrCopy.splice(i, 1);
        }
      }

      return arrCopy;
    }

    回顾上面的功能，尽管它工作得很好，但我意识到可能会有一些性能改进。同样，使用ES6而不是ES5是一种更好的方法。为此，这是改进的代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    const arrayWithoutFastest = (() => {
      const isArray = canBeArray => ('isArray' in Array)
        ? Array.isArray(canBeArray)
        : Object.prototype.toString.call(canBeArray) === '[object Array]';

      let mapIncludes = (map, key) => map.has(key);
      let objectIncludes = (obj, key) => key in obj;
      let includes;

      function arrayWithoutFastest(arr, ...thisArgs) {
        let withoutValues = isArray(thisArgs[0]) ? thisArgs[0] : thisArgs;

        if (typeof Map !== 'undefined') {
          withoutValues = withoutValues.reduce((map, value) => map.set(value, value), new Map());
          includes = mapIncludes;
        } else {
          withoutValues = withoutValues.reduce((map, value) => { map[value] = value; return map; } , {});
          includes = objectIncludes;
        }

        const arrCopy = [];
        const length = arr.length;

        for (let i = 0; i < length; i++) {
          // If value is not in exclude list
          if (!includes(withoutValues, arr[i])) {
            arrCopy.push(arr[i]);
          }
        }

        return arrCopy;
      }

      return arrayWithoutFastest;  
    })();

    如何使用：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    const arr = [1,2,3,4,5,"name", false];

    arrayWithoutFastest(arr, 1); // will return array [2,3,4,5,"name", false]
    arrayWithoutFastest(arr, 'name'); // will return [2,3,4,5, false]
    arrayWithoutFastest(arr, false); // will return [2,3,4,5]
    arrayWithoutFastest(arr,[1,2]); // will return [3,4,5,"name", false];
    arrayWithoutFastest(arr, {bar:"foo
    <hr>[cc lang="    javascript"]  Array.prototype.removeItem = function(a) {
                for (i = 0; i < this.length; i++) {
                    if (this[i] == a) {
                        for (i2 = i; i2 < this.length - 1; i2++) {
                            this[i2] = this[i2 + 1];
                        }
                        this.length = this.length - 1
                        return;
                    }
                }
            }

        var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];
        recentMovies.removeItem('Superman');

    您有1到9个数组，您希望删除5个使用下面的代码。

    1
    2
    3
    4
    5
    6
    7
    var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

    var newNumberArray = numberArray.filter(m => {
      return m !== 5;
    });

    console.log("new Array, 5 removed", newNumberArray);

    如果要多个值，例如-1、7、8

    1
    2
    3
    4
    5
    6
    7
    var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

    var newNumberArray = numberArray.filter(m => {
      return (m !== 1) && (m !== 7) && (m !== 8);
    });

    console.log("new Array, 5 removed", newNumberArray);

    如果要删除数组ex中的数组值：-[3,4,5]

    1
    2
    3
    4
    5
    6
    7
    8
    var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
    var removebleArray = [3,4,5];

    var newNumberArray = numberArray.filter(m => {
        return !removebleArray.includes(m);
    });

    console.log("new Array, [3,4,5] removed", newNumberArray);

    包括支持的浏览器IS链接

    按索引删除

    返回数组副本而索引处没有元素的函数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    /**
    * removeByIndex
    * @param {Array} array
    * @param {Number} index
    */
    function removeByIndex(array, index){
        return array.filter(function(elem, _index){
            return index != _index;
        });
    }
    l = [1,3,4,5,6,7];
    console.log(removeByIndex(l, 1));

    $> [ 1, 4, 5, 6, 7 ]

    按值删除

    返回不带值的数组副本的函数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    /**
    * removeByValue
    * @param {Array} array
    * @param {Number} value
    */
    function removeByValue(array, value){
        return array.filter(function(elem, _index){
            return value != elem;
        });
    }
    l = [1,3,4,5,6,7];
    console.log(removeByValue(l, 5));

    $> [ 1, 3, 4, 6, 7]
    相关讨论

    创建一个新的数组。

    1
    var my_array = new Array();

    添加到这个数组元素

    1
    my_array.push("element1");

    功能指数(指数- 1或不返回时发现的)：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    var indexOf = function(needle)
    {
        if(typeof Array.prototype.indexOf === 'function') // newer browsers
        {
            indexOf = Array.prototype.indexOf;
        }
        else // older browsers
        {
            indexOf = function(needle)
            {
                var index = -1;

                for(var i = 0; i < this.length; i++)
                {
                    if(this[i] === needle)
                    {
                        index = i;
                        break;
                    }
                }
                return index;
            };
        }

        return indexOf.call(this, needle);
    };

    本元(考核指标的测试与Firefox和IE8的+)：

    1
    var index = indexOf.call(my_array,"element1");

    1去除从阵元分布指数.

    1
    my_array.splice(index, 1);

    我也遇到了这样的情况：我必须从Array中删除一个元素。.indexOf不在IE*工作，所以分享了我正在工作的jQuery.inArray()解决方案。

    1
    2
    3
    4
    5
    var index = jQuery.inArray(val,arr);
    if (index > -1) {
        arr.splice(index, 1);
        //console.log(arr);
    }
    相关讨论

    我认为许多javascript指令对于函数式编程来说都不是很好的考虑。拼接返回删除的元素，其中大部分时间需要缩减的数组。这很糟糕。

    假设您正在进行递归调用，并且必须传递一个包含少一个项的数组，可能没有当前的索引项。或者假设您正在执行另一个递归调用，并且必须传递一个被推送元素的数组。

    在这两种情况下，您都不能执行myRecursiveFunction(myArr.push(c))或myRecursiveFunction(myArr.splice(i,1))。事实上，第一个白痴将传递数组的长度，第二个白痴将传递删除的元素作为参数。

    所以事实上我所做的…为了删除数组元素并将结果作为参数传递给函数，我执行以下操作

    1
    myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))

    当要推的时候，那就更愚蠢了…我确实喜欢，

    1
    myRecursiveFunction((myArr.push(c),myArr))

    我相信一种适当的函数语言，一个方法改变它所调用的对象，结果必须返回对这个对象的引用。

    2017～05-08

    大多数给定的答案都适用于严格的比较，这意味着两个对象引用内存中完全相同的对象(或是基元类型)，但通常您希望从具有特定值的数组中删除非基元对象。例如，如果您调用一个服务器，并希望检查一个检索到的对象与一个本地对象。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    const a = {'field': 2} // Non-primitive object
    const b = {'field': 2} // Non-primitive object with same value
    const c = a            // Non-primitive object that reference the same object as"a"

    assert(a !== b) // Don't reference the same item, but have same value
    assert(a === c) // Do reference the same item, and have same value (naturally)

    //Note: there are many alternative implementations for valuesAreEqual
    function valuesAreEqual (x, y) {
       return  JSON.stringify(x) === JSON.stringify(y)
    }


    //filter will delete false values
    //Thus, we want to return"false" if the item
    // we want to delete is equal to the item in the array
    function removeFromArray(arr, toDelete){
        return arr.filter(target => {return !valuesAreEqual(toDelete, target)})
    }

    const exampleArray = [a, b, b, c, a, {'field': 2}, {'field': 90}];
    const resultArray = removeFromArray(exampleArray, a);

    //resultArray = [{'field':90}]

    ValuesAreEqual有其他/更快的实现，但这确实起到了作用。如果要检查特定字段(例如，一些检索到的UUID与本地UUID)，也可以使用自定义比较器。

    还要注意，这是一个函数操作，意味着它不会改变原始数组。

    相关讨论

    In CoffeeScript:

    1
    my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value

    使用jquery的inarray:

    1
    2
    3
    A = [1, 2, 3, 4, 5, 6];
    A.splice($.inArray(3, A), 1);
    //It will return A=[1, 2, 4, 5, 6]`

    注意：如果找不到元素，inarray将返回-1。

    相关讨论

    从数组中删除特定元素/字符串可以在一行程序中完成：我仍然认为这是最优雅的一个班轮你可以得到这种类型的问题：

    1
    theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

    其中"the array"是要从中删除特定内容的数组，1是要删除的元素数量。

    相关讨论

    Vanilla JavaScript(ES5.1)–就地版本

    浏览器支持：Internet Explorer 9或更高版本(详细的浏览器支持)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    /**
     * Removes all occurences of the item from the array.
     *
     * Modifies the array"in place", i.e. the array passed as an argument
     * is modified as opposed to creating a new array. Also returns the modified
     * array for your convenience.
     */
    function removeInPlace(array, item) {
        var foundIndex, fromIndex;

        // Look for the item (the item can have multiple indices)
        fromIndex = array.length - 1;
        foundIndex = array.lastIndexOf(item, fromIndex);

        while (foundIndex !== -1) {
            // Remove the item (in place)
            array.splice(foundIndex, 1);

            // Bookkeeping
            fromIndex = foundIndex - 1;
            foundIndex = array.lastIndexOf(item, fromIndex);
        }

        // Return the modified array
        return array;
    }

    Vanilla javascript(ES5.1)–不可变版本

    浏览器支持：与普通JavaScript就地版本相同

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    /**
     * Removes all occurences of the item from the array.
     *
     * Returns a new array with all the items of the original array except
     * the specified item.
     */
    function remove(array, item) {
        var arrayCopy;

        arrayCopy = array.slice();

        return removeInPlace(arrayCopy, item);
    }

    香草ES6–不变版

    浏览器支持：Chrome 46、Edge 12、Firefox 16、Opera 37、Safari 8(详细的浏览器支持)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    /**
     * Removes all occurences of the item from the array.
     *
     * Returns a new array with all the items of the original array except
     * the specified item.
     */
    function remove(array, item) {
        // Copy the array
        array = [...array];

        // Look for the item (the item can have multiple indices)
        let fromIndex = array.length - 1;
        let foundIndex = array.lastIndexOf(item, fromIndex);

        while (foundIndex !== -1) {
            // Remove the item by generating a new array without it
            array = [
                ...array.slice(0, foundIndex),
                ...array.slice(foundIndex + 1),
            ];

            // Bookkeeping
            fromIndex = foundIndex - 1;
            foundIndex = array.lastIndexOf(item, fromIndex)
        }

        // Return the new array
        return array;
    }

    你可以在每个iterate array项目和splice如果它存在，它在你的array。

    1
    2
    3
    4
    function destroy(arr, val) {
        for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
        return arr;
    }
    相关讨论

    移除索引i处的元素，而不改变原始数组：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    /**
    * removeElement
    * @param {Array} array
    * @param {Number} index
    */
    function removeElement(array, index) {
       return Array.from(array).splice(index, 1);
    }

    // Another way is
    function removeElement(array, index) {
       return array.slice(0).splice(index, 1);
    }

    我喜欢这个版本的拼接，使用$.inArray按元素的值删除元素：

    1
    2
    3
    4
    5
    $(document).ready(function(){
        var arr = ["C#","Ruby","PHP","C","C++"];
        var itemtoRemove ="PHP";
        arr.splice($.inArray(itemtoRemove, arr),1);
    });
    相关讨论

    我对基本的javascript数组进行了相当有效的扩展：

    1
    2
    3
    4
    5
    6
    7
    Array.prototype.drop = function(k) {
      var valueIndex = this.indexOf(k);
      while(valueIndex > -1) {
        this.removeAt(valueIndex);
        valueIndex = this.indexOf(k);
      }
    };
    相关讨论

    我的解决方案是，借助纯JavaScript，您可以删除数组中的一个或多个项。不需要另一个JavaScript库。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    var myArray = [1,2,3,4,5]; // First array

    var removeItem = function(array,value) {  // My clear function
        if(Array.isArray(value)) {  // For multi remove
            for(var i = array.length - 1; i >= 0; i--) {
                for(var j = value.length - 1; j >= 0; j--) {
                    if(array[i] === value[j]) {
                        array.splice(i, 1);
                    };
                }
            }
        }
        else { // For single remove
            for(var i = array.length - 1; i >= 0; i--) {
                if(array[i] === value) {
                    array.splice(i, 1);
                }
            }
        }
    }

    removeItem(myArray,[1,4]); // myArray will be [2,3,5]

    我刚刚通过Object.defineProperty在Array.prototype上创建了一个polyfill，以便在以后通过for .. in ..迭代数组时删除所需元素，而不会导致错误。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    if (!Array.prototype.remove) {
      // Object.definedProperty is used here to avoid problems when iterating with"for .. in .." in Arrays
      // https://stackoverflow.com/questions/948358/adding-custom-functions-into-array-prototype
      Object.defineProperty(Array.prototype, 'remove', {
        value: function () {
          if (this == null) {
            throw new TypeError('Array.prototype.remove called on null or undefined')
          }

          for (var i = 0; i < arguments.length; i++) {
            if (typeof arguments[i] === 'object') {
              if (Object.keys(arguments[i]).length > 1) {
                throw new Error('This method does not support more than one key:value pair per object on the arguments')
              }
              var keyToCompare = Object.keys(arguments[i])[0]

              for (var j = 0; j < this.length; j++) {
                if (this[j][keyToCompare] === arguments[i][keyToCompare]) {
                  this.splice(j, 1)
                  break
                }
              }
            } else {
              var index = this.indexOf(arguments[i])
              if (index !== -1) {
                this.splice(index, 1)
              }
            }
          }
          return this
        }
      })
    } else {
      var errorMessage = 'DANGER ALERT! Array.prototype.remove has already been defined on this browser. '
      errorMessage += 'This may lead to unwanted results when remove() is executed.'
      console.log(errorMessage)
    }

    删除整数值

    1
    2
    3
    var a = [1, 2, 3]
    a.remove(2)
    a // Output => [1, 3]

    删除字符串值

    1
    2
    3
    var a = ['a', 'ab', 'abc']
    a.remove('abc')
    a // Output => ['a', 'ab']

    删除布尔值

    1
    2
    3
    var a = [true, false, true]
    a.remove(false)
    a // Output => [true, true]

    也可以通过此Array.prototype.remove方法删除数组中的对象。只需指定要删除的Object的key => value。

    删除对象值

    1
    2
    3
    var a = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 3, b: 2}]
    a.remove({a: 1})
    a // Output => [{a: 2, b: 2}, {a: 3, b: 2}]

    还有一个答案，对我来说，越简单越好，正如我们在2018年(接近2019年)所做的那样，我给你这个(接近)一行来回答最初的问题：

    1
    2
    3
    Array.prototype.remove = function (value) {
        return this.filter(f => f != value)
    }

    有用的是，您可以在咖喱表达式中使用它，例如：

    [1,2,3].remove(2).sort()

    使用jquery.grep()：

    1
    2
    3
    4
    5
    6
    7
    var y = [1, 2, 3, 9, 4]
    var removeItem = 9;

    y = jQuery.grep(y, function(value) {
      return value != removeItem;
    });
    console.log(y)
    1
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js">

    相关讨论

    虽然上述大多数答案都回答了这个问题，但还不清楚为什么没有使用slice()方法。是的，filter()满足不变性标准，但是做以下较短的等价物怎么样？

    const myArray = [1,2,3,4];

    现在假设我们应该从数组中删除第二个元素，我们可以简单地做到：const newArray = myArray.slice(0,1).concat(myArray.slice(2,4));// [1,3,4]

    由于元素的简单和不可变的特性，今天在社区中，强烈鼓励使用这种方法从数组中删除元素。一般来说，应避免使用引起突变的方法。例如，鼓励您用concat()替换push()，用slice()替换splice()。

    使用松散比较移除一个值，而不改变原始数组es6

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    /**
     * Removes one instance of `value` from `array`, without mutating the original array. Uses loose comparison.
     *
     * @param {Array} array Array to remove value from
     * @param {*} value Value to remove
     * @returns {Array} Array with `value` removed
     */
    export function arrayRemove(array, value) {
        for(let i=0; i<array.length; ++i) {
            if(array[i] == value) {
                let copy = [...array];
                copy.splice(i, 1);
                return copy;
            }
        }
        return array;
    }

    非常幼稚的实施方式如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    Array.prototype.remove = function(data) {
        const dataIdx = this.indexOf(data)
        if(dataIdx >= 0) {
            this.splice(dataIdx ,1);
        }
        return this.length;
    }

    let a = [1,2,3];
    // this will change arr a to [1, 3]
    a.remove(2);

    我从函数返回数组的长度以符合其他方法，如Array.prototype.push()。

    删除最后一个事件或所有事件，还是第一个事件？

    1
    2
    3
    4
    5
    6
    7
    8
    9
    var array = [2, 5, 9, 5];

    // Remove last occurrence (or all occurrences)
    for (var i = array.length; i--;) {
      if (array[i] === 5) {
         array.splice(i, 1);
         break; // Remove this line to remove all occurrences
      }
    }

    或

    1
    2
    3
    4
    5
    6
    7
    8
    9
    var array = [2, 5, 9, 5];

    // Remove first occurrence
    for (var i = 0; array.length; i++) {
      if (array[i] === 5) {
         array.splice(i, 1);
         break; // Do not remove this line
      }
    }

    这里有许多奇妙的答案，但对我来说，最有效的方法不是完全从数组中删除元素，而是将其值设置为空。这适用于我所拥有的大多数情况，并且是一个很好的解决方案，因为稍后我将使用该变量，不希望它消失，只是暂时为空。此外，这种方法完全兼容跨浏览器。

    1
    array.key = null;

    我做了一个功能

    1
    2
    3
    4
    function pop(valuetoremove, myarray) {
    var indexofmyvalue = myarray.indexOf(valuetoremove);
    myarray.splice(indexofmyvalue, 1);
    }

    像这样使用。

    1
    pop(valuetoremove,myarray);

    干杯！

    相关讨论

    发布我的代码，删除一个数组元素，并减少数组长度。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    function removeElement(idx, arr) {
        // check the index value
        if (idx < 0 || idx >= arr.length) {
            return;
        }
        // shift the elements
        for (var i = idx; i > 0; --i) {
            arr[i] = arr[i - 1];
        }
        // remove the first element in array
        arr.shift();
    }

    对于任何想要复制将返回已删除重复数字或字符串的新数组的方法的人，这已从现有答案中组合在一起：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    function uniq(array) {
      var len = array.length;
      var dupFree = [];
      var tempObj = {};

      for (var i = 0; i < len; i++) {
        tempObj[array[i]] = 0;
      }

      console.log(tempObj);

      for (var i in tempObj) {
        var element = i;
        if (i.match(/\d/)) {
          element = Number(i);
        }
        dupFree.push(element);
      }

      return dupFree;
    }

    要删除特定元素或后续元素，array.splice()方法工作良好。splice()方法通过删除或替换现有元素和/或添加新元素来更改数组的内容，并返回删除的项。

    语法：array.splice(index，deletecount，item1，……，itemx)

    这里，index是强制的，其余参数是可选的。

    例如：

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

    注意：如果知道要删除的元素的索引，可以使用array.splice()方法。但是我们可能会有更多的案例，如下所述-

  • 如果只想删除最后一个元素，可以使用array.pop()。

  • 如果只想删除第一个元素，可以使用array.shift()。

  • 如果只知道元素而不知道元素的位置(或索引)，并希望使用array.filter()方法删除所有匹配的元素：

    1
    2
    3
    4
    5
    6
    let arr = [1, 2, 1, 3, 4, 1, 5, 1];

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

    • 或者使用splice()方法作为-

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

    或假设我们要从数组arr中删除del：

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

    或

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

  • 如果只知道元素而不知道元素的位置(或索引)，并且只想使用splice()方法删除第一个匹配的元素：

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

    我自己也遇到了这个问题(在可以接受更换阵列的情况下)，并用一个简单的：

    1
    2
    3
    var filteredItems = this.items.filter(function (i) {
        return i !== item;
    });

    要给上面的代码片段一点上下文：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    self.thingWithItems = {
            items: [],
            removeItem: function (item) {
                var filteredItems = this.items.filter(function (i) {
                    return i !== item;
                });

                this.items = filteredItems;
            }
        };

    此解决方案应同时适用于引用项和值项。这一切都取决于您是否需要维护对原始数组的引用，以确定此解决方案是否适用。

    从最后删除元素

    1
    arrName.pop();

    从第一个删除元素

    1
    arrName.shift();

    从中间删除

    1
    2
    3
    arrName.splice(starting index,number of element you wnt to delete);

    Ex: arrName.splice(1,1);

    从最后一个元素中删除一个元素

    1
    arrName.splice(-1);

    使用数组索引号删除

    1
     delete arrName[1];

    您的问题没有指出是否需要顺序或不同的值。

    如果您不关心订单，并且容器中的相同值不会超过一次，请使用集合。它会更快，更简洁。

    1
    2
    3
    4
    5
    6
    7
    var aSet = new Set();

    aSet.add(1);
    aSet.add(2);
    aSet.add(3);

    aSet.delete(2);

    真可惜你有一个整数数组，而不是一个键是这些整数的字符串等价物的对象。

    我看过很多这样的答案，据我所见，它们似乎都使用了"蛮力"。我没有检查过每一个，如果不是这样的话，我道歉。对于一个小数组来说，这很好，但是如果其中有000个整数呢？

    如果我错了，请纠正我，但我们不能假设在一个key => value映射中，JS对象就是这样的，关键检索机制可以被假设为高度工程化和优化的吗？(注意，如果某位超级专家告诉我情况并非如此，我可以建议您使用ES6的map类，当然是这样)。

    我只是建议，在某些情况下，最好的解决方案可能是将数组转换为对象…当然，问题是您可能有重复的整数值。我建议把它们放在桶中作为key => value项的"值"部分。(注意，如果您确定没有任何重复数组元素，这可能会简单得多：值"与"键相同，只需转到Object.values(...)返回修改后的数组即可)。

    所以你可以这样做：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
    const f =   function( acc, val, currIndex ){
        // not seen this val before: make 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 );

    输出：

    Object [ <1 empty slot>, Array1, Array[2], Array1, Array1, <5 empty slots>, 46 more… ]

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

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

    您不必全部删除它们：索引值按外观的顺序推送到它们的存储桶中，因此(例如)：

    1
    2
    myIntsMapObj[ 55 ].shift(); // and
    myIntsMapObj[ 55 ].pop();

    将分别删除第一个和最后一个事件。您可以很容易地计算发生的频率，用3s替换所有55s，方法是将一个桶的内容转移到另一个桶，等等。

    …返回修改后的int数组有点复杂：但是每个bucket都包含(在原始数组中)由(string)键表示的值的索引。这些bucket值中的每一个也都是唯一的：所以您将它们转换成一个新对象中的键，以"integer string key"中的(real)整数作为值…然后对这些键进行排序并转到Object.values( ... )。

    这听起来很费时费力…但很明显，一切都取决于环境和预期用途。我的理解是，JS的所有版本和上下文都只在一个线程中运行，线程不会"放手"，因此使用"蛮力"方法可能会出现一些可怕的拥塞：不是由indexOf操作造成的，而是由多个重复的slice/splice操作造成的。

    补遗如果您确定这对您的用例来说太过工程化，那么最简单的"蛮力"方法就是

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

    (是的，其他答案已经找到了Array.prototype.filter…)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    var index,
        input = [1,2,3],
        indexToRemove = 1;
        integers = [];

    for (index in input) {
        if (input.hasOwnProperty(index)) {
            if (index !== indexToRemove) {
                integers.push(result);
            }
        }
    }
    input = integers;

    此解决方案将获取一个输入数组，并在输入中搜索要删除的值。这将循环访问整个输入数组，结果将是第二个数组整数，该数组整数已删除了特定的索引。然后将整数数组复制回输入数组。

    相关讨论

    1
    2
    var array = [2, 5, 9];
    array.splice(array.findIndex(x => x==5), 1);

    使用array.findindex，我们可以减少代码行数。

    developer.mozilla.org开发人员

    相关讨论

    删除带索引和拼接的值！

    1
    2
    3
    4
    5
    6
    7
    function removeArrValue(arr,value) {
        var index = arr.indexOf(value);
        if (index > -1) {
            arr.splice(index, 1);
        }
        return arr;
    }
    相关讨论

    下面的方法将从数组中删除给定值的所有条目，而不创建新数组，并且只使用一个超快的迭代。它在古老的Internet Explorer 5.5浏览器中工作：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    function removeFromArray(arr, removeValue) {
      for (var i = 0, k = 0, len = arr.length >>> 0; i < len; i++) {
        if (k > 0)
          arr[i - k] = arr[i];

        if (arr[i] === removeValue)
          k++;
      }

      for (; k--;)
        arr.pop();
    }

    var a = [0, 1, 0, 2, 0, 3];

    document.getElementById('code').innerHTML =
      'Initial array [' + a.join(', ') + ']';
    //Initial array [0, 1, 0, 2, 0, 3]

    removeFromArray(a, 0);

    document.getElementById('code').innerHTML +=
      'Resulting array [' + a.join(', ') + ']';
    //Resulting array [1, 2, 3]
    1
    <code id="code"></wyn>

    相关讨论

    使用JavaScript的原型功能在数组对象上定义名为remove()的方法。

    Use splice() method to fulfill your requirement.

    请看下面的代码。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    Array.prototype.remove = function(item) {
        // index will have -1 if item does not exist
        // else it will have the index of 1st item found in array
        var index = this.indexOf(item);

        if (index > -1) {
            // splice() method is used to add/remove items(s) in array
            this.splice(index, 1);
        }

        return index;
    }


    var arr = [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];

    // Printing array
    // [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
    console.log(arr)

    // Removing 67 (getting its index i.e. 2)
    console.log("Removing 67")
    var index = arr.remove(67)

    if (index > 0){
        console.log("Item 67 found at", index)
    } else {
        console.log("Item 67 does not exist in array")
    }

    // Printing updated array
    // [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
    console.log(arr)

    // ............... Output ................................
    // [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]
    // Removing 67
    // Item 67 found at  2
    // [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]

    Note: Below is the full example code executed on Node.js REPL which describes the use of push(), pop(), shift(), unshift() and splice() methods.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    > // Defining an array
    undefined
    > var arr = [12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34];
    undefined
    > // Getting length of array
    undefined
    > arr.length;
    16
    > // Adding 1 more item at the end i.e. pushing an item
    undefined
    > arr.push(55);
    17
    > arr
    [ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34, 55 ]
    > // Popping item from array (i.e. from end)
    undefined
    > arr.pop()
    55
    > arr
    [ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
    > // Remove item from beginning
    undefined
    > arr.shift()
    12
    > arr
    [ 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
    > // Add item(s) at beginning
    undefined
    > arr.unshift(67); // Add 67 at begining of the array and return number of items in updated/new array
    16
    > arr
    [ 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
    > arr.unshift(11, 22); // Adding 2 more items at the beginning of array
    18
    > arr
    [ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
    >
    > // Define a method on array (temorarily) to remove an item and return the index of removed item; if it is found else return -1
    undefined
    > Array.prototype.remove = function(item) {
    ... var index = this.indexOf(item);
    ... if (index > -1) {
    ..... this.splice(index, 1); // splice() method is used to add/remove items in array
    ..... }
    ... return index;
    ... }
    [Function]
    >
    > arr
    [ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
    >
    > arr.remove(45);   // Remove 45 (You will get the index of removed item)
    3
    > arr
    [ 11, 22, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
    >
    > arr.remove(22)    // Remove 22
    1
    > arr
    [ 11, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
    > arr.remove(67)    // Remove 67
    1
    > arr
    [ 11, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
    >
    > arr.remove(89)    // Remove 89
    2
    > arr
    [ 11, 67, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
    >
    > arr.remove(100);  // 100 doesn't exist, remove() will return -1
    -1
    >

    谢谢。

    如果必须支持旧版本的Internet Explorer，我建议使用以下polyfill(注意：这不是框架)。它是所有现代数组方法(javascript 1.8.5/ecmascript 5数组附加)的100%向后兼容替换，适用于Internet Explorer 6+、Firefox 1.5+、Chrome、Safari和Opera。

    https://github.com/plusude/array-generics

    相关讨论

    拼接、过滤和删除以从数组中删除元素

    每个数组都有自己的索引，这有助于用索引删除特定元素。

    splice()方法

    阵列。拼接(索引，1)；第一个参数是索引，第二个参数是您

    希望从该索引中删除。

    所以对于单个元素，我们使用1。

    删除方法

    删除数组[索引]

    filter()方法

    如果要删除数组中重复的元素，请筛选该数组。

    removeall=array.filter(e=>e！= ELEM)；

    其中elem是要从数组中移除的元素，array是数组名。

    已经有很多答案了，但是因为还没有人用一行程序来完成，我想我会展示我的方法。它利用了这样一个事实：在创建数组时，string.split()函数将删除所有指定的字符。下面是一个例子：

    1
    2
    3
    var ary = [1,2,3,4,1234,10,4,5,7,3];
    out = ary.join("-").split("-4-").join("-").split("-");
    console.log(out);

    在本例中，将从数组ary中删除所有的4个。但是，需要注意的是，任何包含字符"-"的数组都会导致本例出现问题。简而言之，它将导致join("-")函数不正确地将字符串拼合在一起。在这种情况下，上面截图中的所有"-"字符串都可以替换为原始数组中不使用的任何字符串。下面是另一个例子：

    1
    2
    3
    var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
    out = ary.join("!@#").split("!@#4!@#").join("!@#").split("!@#");
    console.log(out);

    相关讨论

    1
    2
    3
    4
    var array = [1,2,3];
    console.log('Array-First',array); // Array-First 1,2,3
    array.splice(1,1);
    console.log('Array-Second',array); // Array-Second 1,3

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    Array.prototype.remove = function(x) {
        var y=this.slice(x+1);
        var z=[];
        for(i=0;i<=x-1;i++) {
            z[z.length] = this[i];
        }

        for(i=0;i<y.length;i++){
            z[z.length]=y[i];
        }

        return z;
    }
    1
    2
    3
    4
    5
    var arr =[1,2,3,4,5];

    arr.splice(0,1)

    console.log(arr)

    输出[2，3，4，5]；

    方法通过删除或替换现有元素和/或添加新元素来更改数组的内容。

    array.splice(开始[，删除计数[，项1[，项2[，…]]])

    开始

    开始更改数组的索引(原点为0)。如果大于数组的长度，则实际的起始索引将设置为数组的长度。如果为负，则将从数组末尾(原点为-1)开始许多元素，如果绝对值大于数组长度，则将设置为0。

    删除计数可选

    一个整数，指示要删除的旧数组元素的数目。如果省略了deleteCount，或者其值大于array.length-start(即，如果它大于数组中剩余元素的数目，则从start开始)，则将删除从数组的start到end的所有元素。如果deleteCount为0或负数，则不删除任何元素。在这种情况下，您应该至少指定一个新元素(见下文)。

    第1项，第2项，…可选的

    要添加到数组中的元素，从开始索引开始。如果不指定任何元素，splice()将只从数组中删除元素。

    欲了解更多参考资料，请浏览：

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

    减持法利润如下：

    案例a)如果需要按索引删除元素：

    1
    2
    3
    function remove(arr, index) {
      return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
    }

    案例b)如果您需要通过元素的值(int)移除元素：

    1
    2
    3
    function remove(arr, value) {
      return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
    }

    因此，通过这种方式，我们可以返回一个新的数组(这将是一种很酷的功能性方法——比使用push或splice要好得多)。

    通常情况下，最好使用过滤函数创建一个新的数组。

    1
    2
    const array = [1,2,3,4];
    array = array.filter(i => i !== 4); // [1,2,3]

    这也提高了可读性imho。我不喜欢吃薯条，虽然它知道有时候你应该吃。

    1
    2
    3
    4
    5
        Array.prototype.remove = function(start, end) {
            var n = this.slice((end || start) + 1 || this.length);
            return this.length = start < 0 ? this.length + start : start,
            this.push.apply(this, n)
        }

    开始和结束可以是负数，在这种情况下，它们从数组的结尾开始计数。如果只指定了start，则只删除一个元素。函数返回新的数组长度。

    1
    2
    3
    z=[0,1,2,3,4,5,6,7,8,9];

    newlength=z.remove(2,6);

    (8)【0、1、7、8、9】

    1
    2
    3
    z=[0,1,2,3,4,5,6,7,8,9];

    newlength=z.remove(-4,-2);

    (7)【0、1、2、3、4、5、9】

    1
    2
    3
    z=[0,1,2,3,4,5,6,7,8,9];

    newlength=z.remove(3,-2);

    (4)【0、1、2、9】

    1
    2
    3
    var ar1 = [1,2,3,4,5,6,7,8,9]
    var toBeRemoved = 2;
    ar1.splice( (ar1.length -toBeRemoved) , toBeRemoved);
    相关讨论

    1
    2
    let array = [5,5,4,4,2,3,4]    
    let newArray = array.join(',').replace('5','').split(',')

    如果要删除一个当前项，则此示例有效。