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

Question

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

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

我必须使用核心 JavaScript - 没有框架是允许的。

Answer 1

找到要删除的数组元素的index，然后使用splice删除该索引。

  

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

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的第二个参数是要删除的元素数。请注意splice修改了数组并返回一个包含已删除元素的新数组。

Answer 2

我不知道你期待array.remove(int)的表现如何。我可以想到你可能想要的三种可能性。

删除索引i处的数组元素：

array.splice(i, 1);

如果要从数组中删除值为number的每个元素：

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

如果您只想让索引i的元素不再存在，但您不希望其他元素的索引发生变化：

delete array[i];

Answer 3

于2016年10月编辑

• 简单，直观，明确（https://en.wikipedia.org/wiki/Occam%27s_razor）
• 不可变（原始阵列保持不变）
• 使用标准JS功能，如果您的浏览器不支持它们 - 使用polyfill

在这个代码示例中，我使用“array.filter（...）”函数从数组中删除不需要的项目，此函数不会更改原始数组并创建新数组。如果您的浏览器不支持此功能（例如版本9之前的IE或版本1.5之前的Firefox），请考虑使用the filter polyfill from Mozilla。

删除项目（ECMA-262 Edition 5 code aka oldstyle JS）

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代码）

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“（）=＆gt; {}”IE中根本不支持箭头功能语法，Chrome版本不支持45版本，Firefox版本支持22版本，Safari版本支持10版本。要在旧版浏览器中使用ES2015语法，您可以使用BabelJS

---

删除多个项目（ES2016代码）

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

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 ]

重要“array.includes（...）”功能根本不支持IE浏览器，Chrome之前的47版本，Firefox之前的43版本，Safari之前的9版本以及Edge之前的14版本here is polyfill from Mozilla

删除多个项目（尖端实验性JavaScript ES2018？）

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

Try it yourself in BabelJS :)

<强>参考

• Array.prototype.includes
• This-Binding Syntax Proposal
• Functional composition

Answer 4

取决于您是否想保留空位。

如果你想要一个空槽，删除就可以了：

delete array[ index ];

如果不这样做，则应使用splice方法：

array.splice( index, 1 );

如果你需要该项的值，你可以只存储返回的数组的元素：

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

如果您想按某种顺序执行此操作，可以使用array.pop()作为最后一个，或array.shift()作为第一个（并且两者都返回项目的值）。

如果您不知道该项目的索引，可以使用array.indexOf( item )获取该项目（在if()中获取一个项目或在while()中获取所有项目他们）。 array.indexOf( item )返回索引，如果未找到则返回-1。

Answer 5

一位朋友在Internet Explorer 8遇到问题，并告诉我他做了什么。我告诉他这是错的，他告诉我他在这里得到了答案。当前的最佳答案不适用于所有浏览器（例如Internet Explorer 8），它只会删除第一次出现的项目。

从数组中删除所有实例

function remove(arr, item) {
    for (var i = arr.length; i--;) {
        if (arr[i] === item) {
            arr.splice(i, 1);
        }
    }
}

它向后循环遍历数组（因为索引和长度会随着项目的移除而改变）并删除项目（如果已找到）。它适用于所有浏览器。

Answer 6

有两种主要方法：

1. splice（）：anArray.splice(index, 1);

2. 删除：delete anArray[index];

对数组使用delete时要小心。它有利于删除对象的属性但对数组不太好。最好对数组使用splice。

请注意，当您对数组使用delete时，anArray.length的结果可能会出错。换句话说，delete将删除元素，但不会更新length属性的值。

使用删除后，您还可能会在索引号中出现漏洞，例如：你可能最终得到索引1,3,4,8,9,11和使用删除之前的长度。 在这种情况下，所有索引for循环都会崩溃，因为索引不再是顺序的。

如果由于某种原因被迫使用delete，那么当需要循环遍历数组时，应该使用for each循环。事实上，如果可能的话，总是避免使用索引for循环。这样代码就会更健壮，不易出现索引问题。

Answer 7

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

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)

Answer 8

无需使用indexOf或splice。但是，如果您只想删除一个元素，它会表现得更好。

查找并移动（移动）：

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）：

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

仅使用splice（拼接）：

function splice(arr, val) {
  for (var i = arr.length; i--;) {
    if (arr[i] === val) {
      arr.splice(i, 1);
    }
  }
}

nodejs上运行时间为1000个元素（平均超过10000次运行）的数组：

indexof 比 move 慢大约10倍。即使通过删除对 splice 中的indexOf的调用进行了改进，它也会比 move 更糟糕。

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

Answer 9

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

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

用法

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

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

定义

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

Answer 10

John Resig posted a good implementation：

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

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

// 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日）：

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个元素：

myArray.remove(8);

你最终得到一个8元素阵列。不知道为什么，但我确认John的原始实现没有这个问题。

Answer 11

Underscore.js可用于解决多个浏览器的问题。它使用内置浏览器方法（如果存在）。如果它们不存在，就像旧的Internet Explorer版本一样，它使用自己的自定义方法。

从数组中删除元素的简单示例（来自网站）：

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

Answer 12

您可以使用filter方法轻松完成：

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

的组合工作得更快

Answer 13

如果要删除已删除位置的新数组，可以随时删除特定元素并过滤掉数组。对于没有实现过滤方法的浏览器，它可能需要array object的扩展，但从长远来看，它更容易，因为你所做的只是：

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]

Answer 14

您可以使用ES6。

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

输出：

["1", "2", "4", "5", "6"]

Answer 15

查看此代码。它适用于每个主要浏览器。

remove_item = function (arr, value) {
    var b = '';
    for (b in arr) {
        if (arr[b] === value) {
            arr.splice(b, 1);
            break;
        }
    }
    return arr;
}

调用此函数

remove_item(array,value);

Answer 16

你可以使用lodash _.pull（变异数组），_.pullAt（变异数组）或_.without（不会改变数组），

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

Answer 17

好的，例如，你有以下数组：

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

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

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

如果您重复使用此功能，您可以编写一个可重复使用的函数，该函数将附加到Native数组函数，如下所示：

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]，那该怎么办？

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

我们需要一个循环来检查所有这些，但更简单，更有效的方法是使用内置的JavaScript函数，所以我们编写一个使用如下所示的过滤器的函数：

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或者Underscore，有关更多信息，请查看lodash _.pull，_.pullAt或_.without。

Answer 18

ES10更新

这篇文章总结了从ECMAScript 2019（ES10）开始从数组中删除元素的常用方法。

1。一般情况

1.1。使用.splice()

按值删除Array元素

| 就地：是|
| 删除重复项：是（循环），否（indexOf）|
| 按值/索引：按索引|

如果知道要从数组中删除的值，则可以使用splice方法。首先，您必须确定目标项目的索引。然后，您将索引用作开始元素，并仅删除一个元素。

// With a 'for' loop
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for( let i = 0; i < arr.length; i++){
  if ( arr[i] === 5) {
    arr.splice(i, 1);
  }
} // => [1, 2, 3, 4, 6, 7, 8, 9, 0]

// With the .indexOf() method
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf(5);
arr.splice(i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]

1.2。使用.filter()方法删除数组元素

| 就地：否|
| 删除重复项：是|
| 按值/索引：按值|

通过提供过滤功能，可以从数组 中过滤特定元素。然后，对数组中的每个元素调用此函数。

const value = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter(item => item !== value)
console.log(arr)
// [ 1, 2, 4, 5 ]

1.3。通过扩展Array.prototype

删除Array元素

| 就地：是/否（取决于实施情况）|
| 删除重复项：是/否（取决于实施情况）|
| 按值/索引：按索引/按值（取决于实现方式）|

可以使用其他方法扩展Array的原型。这样的方法将可以在创建的数组上使用。

注意：有人认为，从JavaScript的标准库（例如Array）中扩展对象的原型是一种反模式。

// In-place, removes all, by value implementation
Array.prototype.remove = function(item) {
    for (let i = 0; i < this.length; i++) {
        if (this[i] === item) {
            this.splice(i, 1);
        }
    }
}
const arr1 = [1,2,3,1];
arr1.remove(1) // arr1 equals [2,3]

// Non-stationary, removes first, by value implementation
Array.prototype.remove = function(item) {
    const arr = this.slice();
    for (let i = 0; i < this.length; i++) {
        if (arr[i] === item) {
            arr.splice(i, 1);
            return arr;
        }
    }
    return arr;
}
let arr2 = [1,2,3,1];
arr2 = arr2.remove(1) // arr2 equals [2,3,1]

1.4。使用delete运算符

删除数组元素

| 就地：是|
| 删除重复项：否|
| 按值/索引：按索引|

使用delete运算符不会影响length属性。它也不会影响后续元素的索引。数组变得稀疏，这是说删除的项没有删除而是变得不确定的一种奇特的方式。

const arr = [1, 2, 3, 4, 5, 6];
delete arr[4]; // Delete element with index 4
console.log( arr ); // [1, 2, 3, 4, undefined, 6]

delete运算符旨在从JavaScript对象中删除属性，这些对象是数组。

1.5。使用Object实用程序（> = ES10）删除数组元素

| 就地：否|
| 删除重复项：是|
| 按值/索引：按值|

ES10引入了Object.fromEntries，可用于从任何类似Array的对象创建所需的Array，并在此过程中过滤掉不需要的元素。

const object = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values(Object.fromEntries(
  Object.entries(object)
  .filter(([ key, val ]) => val !== valueToRemove)
));
console.log(arr); // [1,2,4]

2。特殊情况

2.1如果元素位于数组的末尾，则将其删除

2.1.1。更改数组length

| 就地：是|
| 删除重复项：否|
| 按值/索引：N / A |

通过将length属性设置为小于当前值的值，可以从数组末尾删除JavaScript Array元素。任何索引大于或等于新长度的元素都将被删除。

const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Set length to remove element
console.log( arr ); // [1, 2, 3, 4, 5]

2.1.2。使用.pop()方法

| 就地：是|
| 删除重复项：否|
| 按值/索引：N / A |

pop方法删除数组的最后一个元素，返回该元素，并更新length属性。 pop方法修改在其上调用它的数组，这意味着与使用delete相比，最后一个元素被完全删除并且数组长度减小了。

const arr = [1, 2, 3, 4, 5, 6];
arr.pop(); // returns 6
console.log( arr ); // [1, 2, 3, 4, 5]

2.2。如果元素位于数组的开头，则将其删除

| 就地：是|
| 删除重复项：否|
| 按值/索引：N / A |

.shift()方法的工作原理与pop方法非常相似，不同之处在于它删除了JavaScript数组的第一个元素而不是最后一个元素。删除元素后，其余元素将向下移。

const arr = [1, 2, 3, 4];
arr.shift(); // returns 1
console.log( arr ); // [2, 3, 4]

2.3。如果元素是数组中的唯一元素，则将其删除

| 就地：是|
| 删除重复项：N / A |
| 按值/索引：N / A |

最快的技术是将数组变量设置为空数组。

let arr = [1];
arr = []; //empty array

通过将长度设置为0，可以使用2.1.1中的替代技术。

Answer 19

我是JavaScript的新手，需要这个功能。我只写了这个：

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

然后当我想使用它时：

//Set-up some dummy data
var dummyObj = {name:"meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];

//Remove the dummy data
removeFromArray(dummyArray, dummyObj);
removeFromArray(dummyArray, "item2");

输出 - 正如所料。 [“item1”，“item1”]

您可能有不同的需求，因此您可以轻松修改它以适应它们。我希望这有助于某人。

Answer 20

以下是使用JavaScript 从数组中删除项目的几种方法。

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

如果您知道项目的索引

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

一种方法是使用slice()：

＆＃13;

＆＃13;

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)

＆＃13;

＆＃13;

＆＃13;

slice()使用收到的索引创建一个新数组。我们只是创建一个新数组，从开始到我们想要删除的索引，并从我们删除的数据到数组末尾之后的第一个位置连接另一个数组。

如果您知道值

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

＆＃13;

＆＃13;

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

console.log(filteredItems)

＆＃13;

＆＃13;

＆＃13;

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

＆＃13;

＆＃13;

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(function(item) {
  return item !== valueToRemove
})

console.log(filteredItems)

＆＃13;

＆＃13;

＆＃13;

或者您可以使用Babel并将ES6代码转发回ES5，以使其更易于浏览旧浏览器，并在代码中编写现代JavaScript。

删除多个项目

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

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

按索引

您可以创建一个功能并删除系列中的项目：

＆＃13;

＆＃13;

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)

＆＃13;

＆＃13;

＆＃13;

按值

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

＆＃13;

＆＃13;

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter(item => !valuesToRemove.includes(item))
// ["a", "b", "e", "f"]

console.log(filteredItems)

＆＃13;

＆＃13;

＆＃13;

避免改变原始数组

splice()（不要与slice()混淆）改变原始数组，应该避免使用。

（最初发布于https://flaviocopes.com/how-to-remove-item-from-array/）

Answer 21

ES6＆amp;没有变异:( 2016年10月）

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

然后：

removeByIndex([33,22,11,44],1) //=> [33,11,44]

Answer 22

更新：仅当您无法使用ECMAScript 2015（以前称为ES6）时，才建议使用此方法。如果你可以使用它，这里的其他答案提供了更简洁的实现。

---

This gist here将解决您的问题，并且还会删除所有出现的参数，而不仅仅是1（或指定的值）。

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

用法：

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]

Answer 23

如果阵列中有复杂对象，可以使用过滤器吗？ 在$ .inArray或array.splice不那么容易使用的情况下。特别是如果对象在数组中可能很浅。

E.g。如果您有一个带有Id字段的对象，并且您希望从数组中删除该对象：

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});

Answer 24

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

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

如果您想删除诸如2之类的特殊索引，请编写以下代码：

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

但是，如果您想删除一个特殊项目，例如3，但您不知道其索引，请执行以下操作：

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

提示：请使用箭头函数进行过滤器回调，除非您得到一个空数组。

Answer 25

你永远不应该改变数组你的数组。因为这是针对功能编程模式的。您可以做的是创建一个新数组，而不引用要使用es6方法filter更改数据的数组;

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

假设你要从数组中删除5，你就可以这样做。

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

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

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

为了进一步了解，您可以阅读Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

上的MDN文档

Answer 26

不可变的单线方式：

const newArr = targetArr.filter(e => e !== elementToDelete);

Answer 27

更现代的ECMAScript 2015（以前称为Harmony或ES 6）方法。给出：

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

然后：

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

屈服：

[1, 2, 4]

您可以使用Babel和polyfill service来确保浏览器能够很好地支持此功能。

Answer 28

我知道已经有很多答案，但其中许多似乎使问题复杂化。这是一种删除键的所有实例的简单递归方法 - 调用self直到找不到索引。是的，它仅适用于indexOf的浏览器，但它很简单，可以轻松填充。

独立功能

function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

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

原型方法

Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

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

Answer 29

有多种方法可以从 Javascript 数组中删除特定元素。以下是我在研究中能想到的 05 种最佳方法。

1.直接使用'splice()'方法

在以下代码段中，特定预定位置的元素从数组中移除。

• 语法：array_name.splice(begin_index,number_of_elements_remove);
• 申请：

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

console.log("Original array: " + arr);

var removed = arr.splice(4, 2);

console.log("Modified array: " + arr);

console.log("Elements removed: " + removed);

2.使用“splice()”方法按“值”删除元素

在下面的代码段中，我们可以使用 for 循环中的 if 条件删除所有等于预定值的元素（例如：所有等于值 6 的元素）。

var arr = [1, 2, 6, 3, 2, 6, 7, 8, 9, 10];

console.log("Original array: " + arr);

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

  if (arr[i] === 6) {

    var removed = arr.splice(i, 1);
    i--;
  }

}

console.log("Modified array: " + arr); // 6 is removed
console.log("Removed elements: " + removed);

3.使用 'filter()' 方法删除按值选择的元素

类似于使用 'splice()' 方法的实现，但它不是改变现有数组，而是创建一个新的元素数组，并删除了不需要的元素。

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

var filtered = array.filter(function(value, index, arr) {
  return value != 6 ;
});

console.log("Original array: "+array);

console.log("New array created: "+filtered); // 6 is removed

4.使用'Lodash' Javascript 库中的'remove()' 方法

在以下代码段中，Javascript 库中有一个名为“Lodash”的 remove() 方法。此方法也类似于过滤器方法。

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log("Original array: " + array);

var removeElement = _.remove(array, function(n) {
  return n === 6;
});

console.log("Modified array: " + array);
console.log("Removed elements: " + removeElement); // 6 is removed

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>

5.制作自定义删除方法

JavaScript 中没有原生的 'array.remove' 方法，但我们可以使用上述方法创建一个，我们在以下代码片段中实现了该方法。

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

function arrayRemove(arr, value) {

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

console.log("Original array: " + array);
console.log("Modified array: " + arrayRemove(array, 6)); // 6 is removed

最后一种方法（编号 05）更适合解决上述问题。

我想用我们可以用来从数组中删除元素的简单方法来回答。非常感谢您提供宝贵的反馈和意见，以改进我的回答。

Answer 30

如果元素有多个实例，您可以执行向后循环以确保不会搞砸索引。

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

Live Demo

Answer 31

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

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也是一种更好的方法。为此，这是改进的代码：

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

使用方法：

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"}); // will return the same array (new copy)

我目前正在撰写一篇博文，其中我已经对Array的几个解决方案进行了基准测试，并且比较了运行所需的时间。完成该帖后，我将使用链接更新此答案。只是为了让你知道，我已经将上面的内容与lodash进行了比较，如果浏览器支持Map，它就会超过lodash！请注意，我没有使用Array.prototype.indexOf或Array.prototype.includes将exlcudeValues包含在Map或Object中，以便更快地查询！

Answer 32

我还有另一个从数组中删除的好方法：

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

Answer 33

使用数组过滤方法

let array= [1,2,3,4,511,34,511,78,88];

let value = 511;
array = array.filter(element => element !== value);
console.log(array)

Answer 34

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

Answer 35

您有1到9个数组，并且要删除以下代码中的5个。

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

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]

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

包括受支持的浏览器是link

Answer 36

按索引删除

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

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

按值删除

返回没有Value的数组副本的函数。

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

Answer 37

创建新阵列：

var my_array = new Array();

向此阵列添加元素：

my_array.push("element1");

函数indexOf（返回索引或未找到时为-1）：

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 +测试）：

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

删除位于数组索引处的1个元素

my_array.splice(index, 1);

Answer 38

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

以上示例使用array.prototype.filter函数。它遍历所有数组项，并仅返回满足arrow function的那些项。结果，旧数组保持不变，而名为result的新数组包含不等于5的所有项目。您可以自己online对其进行测试。

您可以看到array.prototype.filter的样子：

注意事项

代码质量

在这种情况下，

Array.filter.prototype是删除数字的最易读的方法。它几乎不会出错，并使用了JS核心功能。

为什么不使用array.prototype.map？

对于该用例，有时将

Array.prototype.map视为array.prototype.filter的替代方法。但是不应该使用它。原因是 array.prototype.filter 在概念上用于过滤满足箭头功能的项目（正是我们所需要的），而 array.prototype.map < / strong>用于转换项目。由于我们在迭代项目时不会更改项目，因此要使用的正确函数是array.prototype.filter。

支持

截止到今天（2020年2月21日），互联网用户browsers support array.prototype.filter中的97,05％。因此，总的来说，使用是安全的。但是，IE6-8不支持它。因此，如果您的用例需要对这些浏览器的支持，那么Chris Ferdinanti会提供一个不错的polyfill。

性能

Array.prototype.filter非常适合大多数使用情况。但是，如果您要为高级数据处理寻求一些性能改进，则可以探索一些other options，例如使用pure for。另一个不错的选择是重新考虑是否要处理的数组真的很大，这可能表明JavaScript应该从数据源接收减少的数组以进行处理。

Answer 39

我还遇到了必须从Array删除元素的情况。 .indexOf IE*无法使用jQuery.inArray()分享我的工作var index = jQuery.inArray(val,arr); if (index > -1) { arr.splice(index, 1); //console.log(arr); } 解决方案。

{{1}}

Answer 40

我喜欢这种单线：

arr.includes(val) && arr.splice(arr.indexOf(val), 1)

• ES6（不支持 IE）
• 就地拆除。
• 快速：不进行冗余迭代或重复。
• 支持删除 null 或 undefined 等值

作为原型

// remove by value. return true if value found and removed, false otherwise
Array.prototype.remove = function(val)
{
    return this.includes(val) && !!this.splice(this.indexOf(val), 1);
}

（是的，我阅读了所有其他答案，但找不到将 includes 和 splice 组合在同一行中的答案）

Answer 41

我认为很多JavaScript指令都没有经过深思熟虑的功能编程。 Splice返回已删除的元素，大部分时间需要减少的数组。这很糟糕。

想象一下，你正在做一个递归调用，并且必须传递一个少一个项目的数组，可能没有当前的索引项。或者想象你正在进行另一个递归调用，并且必须传递一个带有元素的数组。

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

所以我实际上做了...为了删除数组元素并将结果作为参数传递给函数我同时执行如下操作

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

当谈到推动更愚蠢......我喜欢，

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

我相信一个正确的函数式语言，一个方法变异它所调用的对象必须返回对该对象的引用。

Answer 42

<强> 2017年5月8日

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

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），也可以使用自定义比较器。

另请注意，这是一个功能操作，这意味着它不会改变原始数组。

Answer 43

从一个数组中删除一个特定的元素/字符串可以在一个衬里完成： 我仍然认为这是解决此类问题的最佳选择：

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

其中'theArray'是要从中删除特定内容的数组，而1是要删除的元素数量。

Answer 44

使用ES6扩展运算符从数组中删除元素的一种不可思议的方式。

假设您要删除4。

let array = [1,2,3,4,5]
const index = array.indexOf(4)
let new_array = [...array.slice(0,index), ...array.slice(index+1, array.length)]
console.log(new_array)
=> [1, 2, 3, 5]

Answer 45

在CoffeeScript中：

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

Answer 46

我测试了 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 在逻辑上更清晰（更易于阅读）并且更适合使用不可变状态的编码风格。因此，是否要进行权衡取决于您。

Answer 47

使用jQuery的InArray：

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

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

Answer 48

我发现此博客文章显示了九种方法：

9 Ways to Remove Elements From A JavaScript Array - Plus How to Safely Clear JavaScript Arrays

我更喜欢使用filter()：

var filtered_arr = arr.filter(function(ele){
   return ele != value;
})

Answer 49

如果array中存在splice项，则可以对其进行迭代，array。

function destroy(arr, val) {
    for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
    return arr;
}

Answer 50

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

$(document).ready(function(){
    var arr = ["C#","Ruby","PHP","C","C++"];
    var itemtoRemove = "PHP";
    arr.splice($.inArray(itemtoRemove, arr),1);
});

Answer 51

Vanilla JavaScript（ES5.1） - 到位版

浏览器支持：Internet Explorer 9或更高版本（detailed browser support）

/**
 * 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） - 不可变版

浏览器支持：与场所版本中的vanilla JavaScript相同

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

Vanilla ES6 - 不可变版

浏览器支持：Chrome 46，Edge 12，Firefox 16，Opera 37，Safari 8（detailed browser support）

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

Answer 52

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

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

Answer 53

在ES6中，Set集合提供了一种delete方法来从数组中删除特定值，然后通过spread operator将Set集合转换为数组。

function deleteItem(list, val) {
    const set = new Set(list);
    set.delete(val);
    
    return [...set];
}

const letters = ['A', 'B', 'C', 'D', 'E'];
console.log(deleteItem(letters, 'C')); // ['A', 'B', 'D', 'E']

Answer 54

通过我的解决方案，您可以使用纯JavaScript删除数组中的一个或多个项目。不需要另一个JavaScript库。

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]

Answer 55

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

Array.prototype.drop = function(k) {
  var valueIndex = this.indexOf(k);
  while(valueIndex > -1) {
    this.removeAt(valueIndex);
    valueIndex = this.indexOf(k);
  }
};

Answer 56

我刚刚通过Array.prototype在Object.defineProperty上创建了一个polyfill，以便在稍后通过for .. in ..

进行迭代时删除数组中的所需元素而不会导致错误

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

删除整数值

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

删除字符串值

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

删除布尔值

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

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

删除对象值

Object

Answer 57

如果数组包含重复值，并且您想删除所有出现的目标，那么这就是方法...

let data = [2, 5, 9, 2, 8, 5, 9, 5];
let target = 5;
data = data.filter(da => da !== target);

注意：-过滤器不会更改原始数组；而是创建一个新数组。

所以再次分配很重要。

这导致了另一个问题。您不能使变量const。应该是let或var。

Answer 58

该函数从数组中的特定位置移除一个元素。

array.remove(position);

Array.prototype.remove = function (pos) {
    this.splice(pos, 1);
}

var arr = ["a", "b", "c", "d", "e"];
arr.remove(2); // remove "c"
console.log(arr);

如果您不知道要删除的项目的位置，请使用：

array.erase(element);

Array.prototype.erase = function(el) {
    let p = this.indexOf(el); // indexOf use strict equality (===)
    if(p != -1) {
        this.splice(p, 1);
    }
}

var arr = ["a", "b", "c", "d", "e"];
arr.erase("c");
console.log(arr);

Answer 59

使用 filter 方法尝试此代码，您可以从数组中删除任何特定项。

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
function removeItem(arr, value) {
  return arr.filter(function (ele) {
    return ele !== value;
  });
}
console.log(removeItem(arr, 6));

Answer 60

使用jQuery.grep()：

＆＃13;

＆＃13;

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

y = jQuery.grep(y, function(value) {
  return value != removeItem;
});
console.log(y)

＆＃13;

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>

＆＃13;

＆＃13;

＆＃13;

Answer 61

虽然上面的大多数答案都回答了这个问题，但是为什么没有使用slice()方法还不够明确。是的，filter()符合不变性标准，但如何执行以下更短的等效项：

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

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

由于其简单且不可改变的特性，今天在社区中强烈鼓励这种从数组中删除元素的方式。通常，应避免引起突变的方法。例如，我们鼓励您将push()替换为concat()，将splice()替换为slice()

Answer 62

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

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

Answer 63

还有另一个答案，对我来说，越简单越好，就像我们在2018年（2019年左右）一样，我给你这个（附近）班轮以回答原始问题：

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

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

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

Answer 64

性能

今天09.12.2019我在MacOs HighSierra 10.13.6上针对所选解决方案进行了性能测试。我显示了delete（A），但是我没有将其与其他方法相比使用，因为它在数组中留有空白。

结论

• 最快的解决方案是array.splice（C）（对于第二次访问小型阵列的野生动物园除外）
• 对于大型数组，array.slice+splice（H）是针对Firefox和Safari的最快的不变解决方案； Array.from（B）的Chrome浏览器最快
• 可变解决方案通常比不可变解决方案快1.5到6倍
• 对于野生动物园的小桌子，令人惊奇的可变解（C）比不可变解（G）慢

详细信息

在测试中，我以不同的方式从数组中删除了中间元素。 A，C 解决方案已就位。 B，D，E，F，G，H 解决方案是不变的。

包含10个元素的数组的结果

将array.splice（C）设置为最快的就地解决方案。 array.filter（D）最快的不变方案。最慢的是array.slice（F）。您可以在计算机here上执行测试。

包含1.000.000个元素的数组的结果

将array.splice（C）设置为最快的就地解决方案（delete（C）的设置与之相似，但速度很快-但它在数组中留有空白位置（因此它不执行“完全删除” ））。 array.slice-splice（H）是最快的不变式解决方案。最慢的是array.filter（D和E）。您可以在计算机here上进行测试。

var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter,array) => console.log(letter, array.join `,`);

function A(array) {
  var index = array.indexOf(5);
  delete array[index];
  log('A', array);
}

function B(array) {
  var index = array.indexOf(5);
  var arr = Array.from(array);
  arr.splice(index, 1)
  log('B', arr);
}

function C(array) {
  var index = array.indexOf(5);
  array.splice(index, 1);
  log('C', array);
}

function D(array) {
  var arr = array.filter(item => item !== 5)
  log('D', arr);
}

function E(array) {
  var index = array.indexOf(5);
  var arr = array.filter((item, i) => i !== index)
  log('E', arr);
}

function F(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0, index).concat(array.slice(index + 1))
  log('F', arr);
}

function G(array) {
  var index = array.indexOf(5);
  var arr = [...array.slice(0, index), ...array.slice(index + 1)]
  log('G', arr);
}

function H(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0);
  arr.splice(index, 1);
  log('H', arr);
}

A([...a]);
B([...a]);
C([...a]);
D([...a]);
E([...a]);
F([...a]);
G([...a]);
H([...a]);

This snippet only presents code used in performance tests - it not perform tests itself.

浏览器比较：Chrome v78.0.0，Safari v13.0.4和Firefox v71.0.0

Answer 65

使用.indexOf（）和.splice（）-可变模式

这里有两种情况：

1. 我们知道索引

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

1. 我们不知道索引，但知道值。

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

Answer 66

splice（）函数能够为您提供数组中的项目，也可以从特定索引中删除项目。

function removeArrayItem(index, array) {
 array.splice(index, 1);
 return array;
}

let array = [1,2,3,4];
let index = 2;
array = removeArrayItem(index, array);
console.log(array);

Answer 67

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

array.key = null;

Answer 68

删除最后一次出现或所有出现次数，还是第一次出现？

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

或

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

Answer 69

我做了一个功能

my %data = map { /(\d+):(\w+)/ } @KitHit; 

并像这样使用。

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

干杯！

Answer 70

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

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

Answer 71

对于任何想要复制一个方法的人来说，这个方法将返回一个删除了重复数字或字符串的新数组，这已经从现有答案中汇总了：

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

Answer 72

<md-error *ngIf="locaCd.errors?.pattern">
 onny blank is unacceptable AND must be filled by a~z,A~Z or number.
</md-error>

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

developer.mozilla.org

Answer 73

非常天真的实施如下：

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()。

Answer 74

您的问题并未表明是否需要订单或不同的值。

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

var aSet = new Set();

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

aSet.delete(2);

Answer 75

[2,3,5].filter(i => ![5].includes(i))

Answer 76

如果您使用的是现代浏览器，则可以使用 .filter。

Array.prototype.remove = function(x){
    return this.filter(function(v){
        return v !== x;
    });
};

var a = ["a","b","c"];
var b = a.remove('a');

Answer 77

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;

此解决方案将采用一系列输入，并将在输入中搜索要删除的值。这将循环遍历整个输入数组，结果将是已删除特定索引的第二个数组整数。然后将整数数组复制回输入数组。

Answer 78

使用索引和拼接删除值！

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

Answer 79

以下方法将从数组中删除给定值的所有条目，而不创建新数组，并且只有一次迭代 superfast 。它适用于古代Internet Explorer 5.5浏览器：

＆＃13;

＆＃13;

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 +=
  '<br>Resulting array [' + a.join(', ') + ']';
//Resulting array [1, 2, 3]

＆＃13;

<code id="code"></code>

＆＃13;

＆＃13;

＆＃13;

Answer 80

你有一个整数数组是多么遗憾，而不是一个对象，其中键是这些整数的字符串等价物。

我已经查看了很多这些答案，就我所见，他们似乎都使用“蛮力”。我没有检查过每一个，如果不是这样，请道歉。对于一个小的数组，这很好，但如果你有000个整数呢？

如果我错了，请纠正我，但我们不能假设在key => value地图中，JS对象的类型，可以假设密钥检索机制经过高度设计和优化？ （注意，如果某位超级专家告诉我情况并非如此，我建议使用ES6的Map class代替，当然也会这样。）

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

所以你可以这样做：

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

输出：

  

对象[＆lt; 1空插槽＆gt;，数组1，数组[2]，数组1，数组1，＆lt; 5   空插槽＆gt;，46更多......]

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

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

您不必全部删除它们：索引值按照外观顺序被推入其存储桶中，因此（例如）：

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

将分别删除第一个和最后一个匹配项。您可以轻松计算出现频率，通过将一个桶的内容转移到另一个桶等替换所有55s，等等。

...稍微涉及到修改后的int数组：但每个存储桶包含（字符串）键表示的值的索引（在原始数组中）。这些桶值中的每一个也是唯一的：因此您将它们转换为新对象中的键，将“整数字符串键”中的（实际）整数作为值...然后对键进行排序并转到Object.values( ... )。

这听起来非常复杂且耗时......但显然一切都取决于具体情况和所需用法。我的理解是JS的所有版本和上下文只在一个线程中运行，并且线程不会“放开”，因此可能存在一些使用“暴力”方法的可怕拥塞：{{{{{{ 1}}操作，但多次重复indexOf / slice操作。

<强>附录
如果你肯定这对你的用例来说太过工程，那么最简单的“蛮力”方法肯定是

splice

（是的，其他答案已经发现const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ]; const newArray = arr.filter( number => number !== 3 ); console.log( newArray ) ...）

Answer 81

从最后一个元素中删除

arrName.pop();

从第一个

删除元素

arrName.shift();

从中间删除

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

Ex: arrName.splice(1,1);

从最后删除一个元素

arrName.splice(-1);

使用数组索引号删除

 delete arrName[1];

Answer 82

我自己遇到了这个问题（在可以替换阵列的情况下），并用一个简单的方法解决了这个问题：

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

为上面的片段提供一些背景信息：

self.thingWithItems = {
        items: [],
        removeItem: function (item) {
            var filteredItems = this.items.filter(function (i) {
                return i !== item;
            });

            this.items = filteredItems;
        }
    };

此解决方案应同时适用于参考项目和价值项目。这完全取决于您是否需要维护对原始数组的引用，以了解该解决方案是否适用。

Answer 83

要删除特定元素或后续元素，Array.splice()方法效果很好。 splice（）方法通过删除或替换现有元素和/或添加新元素来更改数组的内容，并返回删除的项目。

语法： array.splice（index，deleteCount，item1，.....，itemX）

此处index是必需的，其余参数是可选的。

例如：

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

注意：：如果您知道要删除的元素的索引，则可以使用Array.splice()方法。但是，我们可能还会有其他一些情况，如下所述-

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

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

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]
   

使用splice（）方法作为-

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：

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

OR

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

1. 如果您只知道元素，但不知道元素的位置（或索引），并且想使用splice（）方法删除仅第一个匹配的元素：

   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]
   

Answer 84

通常最好使用过滤器函数创建一个新数组。

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

这也提高了可读性imho。我不喜欢切片，尽管它知道有时您应该这样做。

Answer 85

要从字符串数组中查找和删除特定字符串，请执行以下操作：

var colors = ["red","blue","car","green"];
var carIndex = colors.indexOf("car");//get  "car" index
//remove car from the colors array
colors.splice(carIndex, 1); // colors = ["red","blue","green"]

来源：https://www.codegrepper.com/?search_term=remove+a+particular+element+from+array

Answer 86

你只需要按元素或索引过滤：

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

var result1 = num.filter((el, index) => el != 5) // for remove all 5
var result2 = num.filter((el, index) => index != 5) // for remove item with index == 5

console.log(result1);
console.log(result2);

Answer 87

您可以为此使用过滤器

<?php
    header("Location: http://yoursite.com/some-other-page/"); /* Redirect browser here */
?>

Answer 88

如果您必须支持旧版本的Internet Explorer，我建议使用以下polyfill（注意：这是不是框架）。它是所有现代阵列方法（JavaScript 1.8.5 / ECMAScript 5 Array Extras）的100％向后兼容替代品，适用于Internet Explorer 6 +，Firefox 1.5 +，Chrome，Safari和＆amp;戏。

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

Answer 89

使用JavaScript的原型特征在数组对象上定义一个名为remove（）的方法。

  

使用 splice（）方法来满足您的要求。

请查看以下代码。

(git-hooks-1c) d:\_Работа\Разработка\git-hooks-1c>pip install -e . --process-dependency-links
Obtaining file:///D:/_%D0%A0%D0%B0%D0%B1%D0%BE%D1%82%D0%B0/%D0%A0%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0/git-hooks-1c
DEPRECATION: Dependency Links processing has been deprecated and will be removed in a future release.
Collecting commons>=1.5.0 (from git-hooks-1c==5.2.1)
Collecting parse-1c-build>=3.3.0 (from git-hooks-1c==5.2.1)
Collecting pathlib2>=2.3.2 (from commons>=1.5.0->git-hooks-1c==5.2.1)
  Using cached https://files.pythonhosted.org/packages/66/a7/9f8d84f31728d78beade9b1271ccbfb290c41c1e4dc13dbd4997ad594dcd/pathlib2-2.3.2-py2.py3-none-any.whl
Collecting six>=1.11.0 (from commons>=1.5.0->git-hooks-1c==5.2.1)
  Using cached https://files.pythonhosted.org/packages/67/4b/141a581104b1f6397bfa78ac9d43d8ad29a7ca43ea90a2d863fe3056e86a/six-1.11.0-py2.py3-none-any.whl
Collecting yodl>=1.0.0 (from commons>=1.5.0->git-hooks-1c==5.2.1)
Collecting appdirs>=1.4.3 (from commons>=1.5.0->git-hooks-1c==5.2.1)
  Using cached https://files.pythonhosted.org/packages/56/eb/810e700ed1349edde4cbdc1b2a21e28cdf115f9faf263f6bbf8447c1abf3/appdirs-1.4.3-py2.py3-none-any.whl
Collecting PyYAML>=3.12 (from commons>=1.5.0->git-hooks-1c==5.2.1)
Collecting commons-1c>=1.6.0 (from parse-1c-build>=3.3.0->git-hooks-1c==5.2.1)
  Could not find a version that satisfies the requirement commons-1c>=1.6.0 (from parse-1c-build>=3.3.0->git-hooks-1c==5.2.1) (from versions: )
No matching distribution found for commons-1c>=1.6.0 (from parse-1c-build>=3.3.0->git-hooks-1c==5.2.1)

(git-hooks-1c) d:\_Работа\Разработка\git-hooks-1c>pip install -e . --process-dependency-links --no-cache-dir
Obtaining file:///D:/_%D0%A0%D0%B0%D0%B1%D0%BE%D1%82%D0%B0/%D0%A0%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0/git-hooks-1c
DEPRECATION: Dependency Links processing has been deprecated and will be removed in a future release.
Collecting commons>=1.5.0 (from git-hooks-1c==5.2.1)
  Downloading https://gitlab.com/Cujoko/commons/-/archive/master/commons-master.tar.gz
Collecting parse-1c-build>=3.3.0 (from git-hooks-1c==5.2.1)
  Downloading https://gitlab.com/Cujoko/parse-1c-build/-/archive/master/parse-1c-build-master.tar.gz
Collecting appdirs>=1.4.3 (from commons>=1.5.0->git-hooks-1c==5.2.1)
  Downloading https://files.pythonhosted.org/packages/56/eb/810e700ed1349edde4cbdc1b2a21e28cdf115f9faf263f6bbf8447c1abf3/appdirs-1.4.3-py2.py3-none-any.whl
Collecting pathlib2>=2.3.2 (from commons>=1.5.0->git-hooks-1c==5.2.1)
  Downloading https://files.pythonhosted.org/packages/66/a7/9f8d84f31728d78beade9b1271ccbfb290c41c1e4dc13dbd4997ad594dcd/pathlib2-2.3.2-py2.py3-none-any.whl
Collecting PyYAML>=3.12 (from commons>=1.5.0->git-hooks-1c==5.2.1)
  Downloading https://files.pythonhosted.org/packages/4a/85/db5a2df477072b2902b0eb892feb37d88ac635d36245a72a6a69b23b383a/PyYAML-3.12.tar.gz (253kB)
    100% |████████████████████████████████| 256kB 599kB/s
Collecting six>=1.11.0 (from commons>=1.5.0->git-hooks-1c==5.2.1)
  Downloading https://files.pythonhosted.org/packages/67/4b/141a581104b1f6397bfa78ac9d43d8ad29a7ca43ea90a2d863fe3056e86a/six-1.11.0-py2.py3-none-any.whl
Collecting yodl>=1.0.0 (from commons>=1.5.0->git-hooks-1c==5.2.1)
  Downloading https://files.pythonhosted.org/packages/63/e0/36db91311d51f94568f36a3a297416fcbd8e84a5eb2bab61c9b34579c49d/yodl-1.0.0.tar.gz
Collecting commons-1c>=1.6.0 (from parse-1c-build>=3.3.0->git-hooks-1c==5.2.1)
  Downloading https://gitlab.com/Cujoko/commons-1c/-/archive/master/commons-1c-master.tar.gz
Installing collected packages: appdirs, six, pathlib2, PyYAML, yodl, commons, commons-1c, parse-1c-build, git-hooks-1c
  Running setup.py install for PyYAML ... done
  Running setup.py install for yodl ... done
  Running setup.py install for commons ... done
  Running setup.py install for commons-1c ... done
  Running setup.py install for parse-1c-build ... done
  Running setup.py develop for git-hooks-1c
Successfully installed PyYAML-3.12 appdirs-1.4.3 commons-1.5.0 commons-1c-1.6.0 git-hooks-1c parse-1c-build-3.3.0 pathlib2-2.3.2 six-1.11.0 yodl-1.0.0

  

注意：以下是在 Node.js REPL 上执行的完整示例代码，它描述了push（），pop（），shift（），unshift的使用（ ）和splice（）方法。

dependency_links=[
    ...
    'https://gitlab.com/Cujoko/commons-1c/-/archive/master/commons-1c-master.tar.gz#egg=commons_1c-1.6.0',
    ...
],
install_requires=[
    ...
    'commons-1c>=1.6.0',
    ...
]

感谢。

Answer 90

剪接，过滤和删除以从数组中删除元素

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

splice（）方法

array.splice（index， 1 ）; 第一个参数是索引，第二个参数是您的元素数量

想从该索引中删除。

因此对于单个元素，我们使用1。

删除方法

删除数组[索引]

filter（）方法

如果要删除在数组中重复的元素，请过滤数组。

removeAll = array.filter（e => e！= elem）;

其中elem是您要从数组中删除的元素，而array是您的数组名称

Answer 91

这里的大多数答案都使用-提供解决方案-

1. indexOf和拼接
2. 删除
3. 过滤器
4. 常规for loop

尽管所有解决方案都可以使用这些方法，但我认为我们可以使用字符串操作。

有关此解决方案的注意事项-

1. 它将在数据中留下漏洞。 （可以通过额外的过滤器删除）
2. 该解决方案不仅适用于原始搜索值，还适用于对象。

诀窍是-

1. stringify输入数据集和搜索值
2. 用空字符串替换输入数据集中的搜索值
3. 在定界符split上返回,数据。

    remove = (input, value) => {
        const stringVal = JSON.stringify(value);
        const result = JSON.stringify(input)

        return result.replace(stringVal, "").split(",");
    }

在这里创建了带有对象和数字测试的JS小提琴-https://jsfiddle.net/4t7zhkce/33/

检查小提琴中的remove方法。

Answer 92

可以使用filter选项在一行中删除数组中的特定元素，并且所有浏览器都支持：https://caniuse.com/#search=filter%20array

function removeValueFromArray(array, value) {
    return array.filter(e => e != value)
}

我在这里测试了此功能：https://bit.dev/joshk/jotils/remove-value-from-array/~code#test.ts

Answer 93

最简单的方法可能是使用过滤器功能。这是一个示例：

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

Answer 94

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

Answer 95

已经有很多答案，但因为还没有人用一个班轮做过，我想我会显示我的方法。它利用了string.split（）函数在创建数组时将删除所有指定字符的事实。这是一个例子：

＆＃13;

＆＃13;

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

＆＃13;

＆＃13;

＆＃13;

在此示例中，所有4个都将从阵列ary中删除。但是，重要的是要注意任何包含字符＆＃34; - ＆＃34;的数组。将导致此示例出现问题。简而言之，它将导致连接（＆＃34; - ＆＃34;）函数将您的字符串拼凑不正确。在这种情况下，所有的＆＃34; - ＆＃34;上面snipet中的字符串可以替换为原始数组中不使用的任何字符串。这是另一个例子：

＆＃13;

＆＃13;

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

＆＃13;

＆＃13;

＆＃13;

Answer 96

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

arr.splice(0,1)

console.log(arr)

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

Answer 97

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

array.splice（start [，deleteCount [，item1 [，item2 [，...]]]]）

开始

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

deleteCount可选

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

项目1，项目2，...可选

要添加到数组中的元素，从起始索引开始。如果您未指定任何元素，则splice（）只会从数组中删除元素。

有关更多参考资料，请通过：

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice

Answer 98

采用减少方法的利润如下：

情况a）如果您需要按索引删除元素

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

情况b）如果您需要通过元素（int）的值删除元素：

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

因此，通过这种方式，我们可以返回一个删除了元素的新数组（这将是一种很酷的功能方式-比使用push或splice更好）。

Answer 99

您可以扩展数组对象以定义自定义删除函数，如下所示：

let numbers = [1,2,4,4,5,3,45,9];

numbers.delete = function(value){
    var indexOfTarget = this.indexOf(value)

    if(indexOfTarget !== -1)
    {
        console.log("array before delete " + this)
        this.splice(indexOfTarget, 1)
        console.log("array after delete " + this)
    }
    else{
        console.error("element " + value + " not found")
    }
}
numbers.delete(888)
// Expected output:
// element 888 not found
numbers.delete(1)

// Expected output;
// array before delete 1,2,4,4,5,3,45,9
// array after delete 2,4,4,5,3,45,9

Answer 100

非就地解决方案

arr.slice(0,i).concat(arr.slice(i+1));

let arr = [10, 20, 30, 40, 50]

let i = 2 ; // position to remove (starting from 0)
let r = arr.slice(0,i).concat(arr.slice(i+1));

console.log(r);

Answer 101

删除单个元素

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)

Answer 102

您可以创建带有所有Accesors示例的索引

<div >
</div>

function getIndex($id){
  return (
  this.removeIndex($id)
  alert("This element was removed")
  )
}


function removeIndex(){
   const index = $id; 
   this.accesor.id.splice(index.id) // you can use splice for slice index on accesor id and return with message
}

<div>
<fromList>
  <ul>
{...this.array.map( accesors => {
    <li type="hidden"></li>
    <li>{...accesors}</li>
}) 

}
  </ul>
</fromList>

<form id="form" method="post">
<input  id="{this.accesors.id}">
<input type="submit" callbackforApplySend...getIndex({this.accesors.id}) name="sendendform" value="removeIndex" >
</form>

</div>

Answer 103

我建议使用删除和过滤器删除一个数组项：

var arr = [1,2,3,4,5,5,6,7,8,9];
delete arr[5];
arr = arr.filter(function(item){ return item != undefined; });
//result: [1,2,3,4,5,6,7,8,9]

因此，我们只能删除一个特定的数组项，而不是所有具有相同值的项。

Answer 104

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

const script = document.createElement("script");

            script.src = "\\libs\\timeline\\js\\timeline-min.js";
            script.async = true;

            document.body.appendChild(script);

Answer 105

Array.prototype.filter()可以胜任。 例如：

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

removeNum = numToBeRemoved => arr.filter(num => num != numToBeRemoved);

removeNum(5);

OUTPUT:  [1, 2, 3, 4, 6]

Answer 106

您可以使用拼接从数组中删除对象或值。 让我们考虑一个长度为5的值 10,20,30,40,50 的数组，我想从中删除值 30 。

var array = [10,20,30,40,50];
if (array.indexOf(30) > -1) {
  array.splice(array.indexOf(30), 1);
}
console.log(array); // [10,20,40,50]

Answer 107

• pop-从数组末尾删除
• shift-从数组的开头删除
• splice-从特定的数组索引中删除
• 过滤器-允许您以编程方式从数组中删除元素

Answer 108

您可以使用 JavaScript 的标准 proto 并定义此函数。例如。

let data = [];
data.__proto__.remove = (n) => { data = data.flatMap((v) => { return v !== n ? v : []; }) };

data = [1, 2, 3];
data.remove(2);
console.log(data); // [1,3]

data = ['a','b','c'];
data.remove('b');
console.log(data); // [a,c]

Answer 109

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

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

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

newlength=z.remove(2,6);

（8）[0，1，7，8，9]

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

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

（7）[[0，1，2，3，4，5，9]

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

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

（4）[[0，1，2，9]

Answer 110

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

Answer 111

您可以使用

Array.splice(index);

Answer 112

  

    

删除特定的数组项

  

403

var cars = ["Apple", "Banana", "Mango", "Orange", "Grapes"];

document.getElementById("demo").innerHTML = cars;

for( var i = 0; i < cars.length; i++){ 
   if ( cars[i] === "Banana") {
     cars.splice(i, 1); 
     i--;
   }
}

document.getElementById("demo2").innerHTML =  cars;

p {
  font-size: 20px; 
  padding: 10px; 
  border: 1px dashed tan;
  color: brown;
}

Answer 113

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

Answer 114

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

如果您想删除一个当前项目，此示例有效。