我不知道你期望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];

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

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

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

splice的第二个参数是要删除的元素数。请注意，splice会就地修改数组并返回一个包含已删除元素的新数组。

出于完整性的原因，这里是函数。第一个函数只删除一个出现的事件（即从[2,5,9,1,5,8,5]中删除5的第一个匹配项），而第二个函数删除所有出现的事件：

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

在TypeScript中，这些函数可以使用类型参数保持类型安全：

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

这取决于你是否想保留一个空位。

如果你做想要一个空插槽：

array[index] = undefined;

如果你不要想要一个空插槽：

//To keep the original://oldArray = [...array];
//This modifies the array.array.splice(index, 1);

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

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

如果您想删除数组的任何一端，您可以使用array.pop()作为最后一个或array.shift()作为第一个（两者都返回项目的值）。

如果您不知道项目的索引，您可以使用array.indexOf(item)来获取它（在if()中获取一个项目或在while()中获取所有项目）。

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

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

有两种主要方法

1. 拼接：anArray.splice(index, 1);

    let fruits = ['Apple', 'Banana', 'Mango', 'Orange']let removed = fruits.splice(2, 1);// fruits is ['Apple', 'Banana', 'Orange']// removed is ['Mango']

2. 删除：delete anArray[index];

    let fruits = ['Apple', 'Banana', 'Mango', 'Orange']let removed = delete fruits(2);// fruits is ['Apple', 'Banana', undefined, 'Orange']// removed is true

在数组中使用delete时要小心。它适合删除对象的属性，但不适合数组。最好使用splice进行数组。

请记住，当您对数组使用delete时，您可能会为anArray.length得到错误的结果。换句话说，delete会删除元素，但不会更新长度属性的值。

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

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

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

这里的要点将解决您的问题，并删除所有出现的参数，而不仅仅是1（或指定的值）。

Array.prototype.destroy = function(obj){// Return null if no objects were found and removedvar destroyed = null;
for(var i = 0; i < this.length; i++){
// Use while-loop to find adjacent equal objectswhile(this[i] === obj){
// Remove this[i] and store it within destroyeddestroyed = this.splice(i, 1)[0];}}
return destroyed;}

用法：

var x = [1, 2, 3, 3, true, false, undefined, false];
x.destroy(3);         // => 3x.destroy(false);     // => falsex;                    // => [1, 2, true, undefined]
x.destroy(true);      // => truex.destroy(undefined); // => undefinedx;                    // => [1, 2]
x.destroy(3);         // => nullx;                    // => [1, 2]

看看这段代码。它适用于每个主要浏览器。

remove_item = function(arr, value) {var b = '';for (b in arr) {if (arr[b] === value) {arr.splice(b, 1);break;}}return arr;};
var array = [1,3,5,6,5,9,5,3,55]var res = remove_item(array,5);console.log(res)

您可以遍历每个array项，如果它存在于您的array中，则遍历splice项。

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

创建新数组：

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和Internet Explorer 8（及更高版本）进行测试）：

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

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

my_array.splice(index, 1);

一位朋友在Internet Explorer 8中遇到问题，并向我展示了他所做的事情。我告诉他这是错误的，他告诉我他在这里得到了答案。当前的顶部答案在所有浏览器中都不起作用（例如Internet Explorer 8），它只会删除第一个出现的项目。

从数组中删除所有实例

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

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

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

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);}console.log(myArray);

John Resig发布了一个很好的实现：

// 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的原始实现没有这个问题。

不需要使用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);}}}

具有1000个元素的数组在Node.js上的运行时间（平均超过10,000次运行）：

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

Remove all occurrences:move 0.0048 msindexof 0.0463 mssplice 0.0359 ms
Remove first occurrence:move_one 0.0041 msindexof_one 0.0021 ms

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 - 1return;}}}
var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];recentMovies.removeItem('Superman');

我还遇到了必须从Array中删除元素的情况。.indexOf在Internet Explorer中不起作用，所以我分享了我的工作jQuery.inArray()解决方案：

var index = jQuery.inArray(val, arr);if (index > -1) {arr.splice(index, 1);//console.log(arr);}

2016年10月编辑

• 做到简单，直观和明确（奥卡姆剃刀）
• 不可变（原始数组保持不变）
• 如果您的浏览器不支持标准JavaScript函数，请使用它们-使用polfill

在此代码示例中，我使用#0函数从数组中删除不需要的项目。此函数不会更改原始数组并创建一个新数组。如果您的浏览器不支持此功能（例如版本9之前的Internet Explorer或版本1.5之前的Firefox），请考虑用#1填充。

删除项目（ECMA-262第5版代码AKA旧式JavaScript）

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 ]

删除项目（ECMAScript 6代码）

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

重要 ECMAScript 6() => {}箭头函数语法在Internet Explorer中完全不受支持，Chrome版本45之前，Firefox版本22之前，Safari版本10之前。要在旧浏览器中使用ECMAScript 6语法，您可以使用BabelJS。

删除多个项目（ECMAScript 7代码）

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

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(...)功能在Internet Explorer中完全不受支持，Chrome版本47之前，Firefox版本43之前，Safari版本9之前，Edge版本14之前，但您可以用#1填充。

删除多个项目（将来，也许）

如果“此绑定语法”提案被接受，你可以这样做：

// 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.prototypearr = arr::remove(2, 3, 5)
console.log(arr)// [ 1, 4 ]

尝试

参考

• Array.prototype.includes
• 功能组合

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

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

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

增编如果你是当然，这对你的用例来说太多了，最简单的“蛮力”方法肯定是

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

（是的，其他答案已经发现了Array.prototype.filter…）

您不应该改变您的数组，因为这违反了函数式编程模式。您可以创建一个新数组，而无需引用您要使用ECMAScript 6方法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上的MDN留档。

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

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

developer.mozilla.org

我刚刚通过Object.defineProperty在Array.prototype上创建了一个Poly填充，以删除数组中所需的元素，而不会在稍后通过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-prototypeObject.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方法删除数组中的对象。您只需要指定要删除的Object中的key => value。

删除对象值

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

一个非常简单的实现如下：

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

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

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

你的问题没有说明顺序或不同的值是否是一个要求。

如果您不关心顺序，并且容器中不会多次出现相同的值，请使用Set。它会更快，更简洁。

var aSet = new Set();
aSet.add(1);aSet.add(2);aSet.add(3);
aSet.delete(2);

这里有一些方法使用JavaScript从数组中删除项目。

不要改变原始数组描述所有方法，并代之以创建一个新方法。

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

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

一种方法是使用slice()：

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

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

如果你知道价值

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

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

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

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。

删除多个项目

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

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

按索引

您可以创建一个函数并删除系列项目：

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)

按价值

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

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)

避免改变原始数组

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

（最初发布在我的网站上https://flaviocopes.com/how-to-remove-item-from-array/）

使用JavaScript的原型设计功能在数组对象上定义一个名为删除（）的方法。

使用拼接方法来满足您的要求。

请看下面的代码。

Array.prototype.remove = function(item) {// 'index' will have -1 if 'item' does not exist,// else it will have the index of the first item found in the arrayvar index = this.indexOf(item);
if (index > -1) {// The splice() method is used to add/remove items(s) in the arraythis.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 ]

备注：下面是在Node.jsREPL上执行的完整示例代码，它描述了ush（）、pop（）、Shift（）、unShift（）和schice（）方法的使用。

> // Defining an arrayundefined> var arr = [12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34];undefined> // Getting length of arrayundefined> arr.length;16> // Adding 1 more item at the end i.e. pushing an itemundefined> 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 beginningundefined> arr.shift()12> arr[ 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]> // Add item(s) at beginningundefined> arr.unshift(67); // Add 67 at beginning of the array and return number of items in updated/new array16> 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 array18> arr[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]>> // Define a method on array (temporarily) to remove an item and return the index of removed item; if it is found else return -1undefined> 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 221> arr[ 11, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]> arr.remove(67)    // Remove 671> arr[ 11, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]>> arr.remove(89)    // Remove 892> 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>

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

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

删除最后一个元素

arrName.pop();

从first中删除一个元素

arrName.shift();

从中间删除

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

从最后删除一个元素

arrName.splice(-1);

使用数组索引号删除

 delete arrName[1];

    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和end可以是负数。在这种情况下，它们从数组的末尾开始计数。

如果仅指定start，则仅删除一个元素。

该函数返回新的数组长度。

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]

你在数组中有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, 1,7 and 8 removed", newNumberArray);

如果您想删除数组中的数组值。示例：[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);

包括支持的浏览器是链接。

我自己也遇到过这个问题（在替换数组是可以接受的情况下），并用一个简单的方法解决了它：

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

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

我想根据ECMAScript 6回答。假设你有一个如下所示的数组：

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]

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

对我来说，越简单越好，就像我们在2018年（接近2019年）一样，我给你这个（接近）一行来回答最初的问题：

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

有用的是你可以在curry表达式中使用它，例如：

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

var arr =[1,2,3,4,5];
arr.splice(0,1)
console.log(arr)

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

从数组中删除特定元素/字符串可以在一行程序中完成：

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

在哪里：

theArray：您要从中删除特定内容的数组

字符串从数组中删除：要删除的字符串，1是要删除的元素数。

注：如果数组中没有“stringToRemveFromArray”，这将删除数组的最后一个元素。

在删除元素之前，先检查元素是否存在于数组中始终是一种很好的做法。

if (theArray.indexOf("stringToRemoveFromArray") >= 0){theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);}

根据您的客户端计算机上是否运行较新版本或较旧版本的Ecmascript：

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

或

var array = ['1','2','3','4','5','6'];var newArray = array.filter(function(item){ return item !== '3' });

其中'3'是要从数组中删除的值。然后数组将变成：['1','2','4','5','6']

要删除特定元素或后续元素，Array.splice（）方法效果很好。

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

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

这里index是强制性的，rest参数是可选的。

例如：

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]

   或者使用plice（）方法：

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

   或

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

4. If you know the element alone but not the position (or index) of the element, and want to delete just very first matching element using splice() method:

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

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

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

开始

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

删除数可选项

一个整数，指示要删除的旧数组元素的数量。

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

item1， item2，…可选

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

更多参考资料，请通过：

Array.prototype.splice（）

减少利润的方法如下：

情况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] : []), []);}

因此，通过这种方式，我们可以返回一个新数组（将以一种很酷的函数式方式-比使用推送或拼接好得多），并删除元素。

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

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

plice（）方法

array.splice(index, 1);

第一个参数是索引，第二个参数是要从该索引中删除的元素数。

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

删除方法

delete array[index]

filter（）方法

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

removeAll = array.filter(e => e != elem);

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

通常，最好使用filter函数创建一个新数组。

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

这也提高了易读性，我不是slice的粉丝，尽管它知道有时你应该去做。

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

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

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 foundnumbers.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

非就地解决方案

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

删除单个元素

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

删除多个元素，就地

这更复杂，以确保算法在O（N）时间内运行。

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

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

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

您可以使用所有访问器示例创建索引：

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

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

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]
console.log(arr)

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

这里的大多数答案给出了一个解决方案-

1. indexOf和plice
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(",");}

这里创建了一个带有对象和数字测试的JSFiddle-https://jsfiddle.net/4t7zhkce/33/

检查小提琴中的remove方法。

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

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

要从字符串数组中查找并删除特定字符串：

var colors = ["red","blue","car","green"];var carIndex = colors.indexOf("car"); // Get "car" index// Remove car from the colors arraycolors.splice(carIndex, 1); // colors = ["red", "blue", "green"]

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

性能

今天（2019-12-09）我在macOS v10.13.6（High Sierra）上为所选解决方案进行性能测试。我显示了delete（A），但与其他方法相比，我不使用它，因为它在数组中留下了空白。

的结论

• 最快的解决方案是array.splice（C）（除了Safari小数组，它有第二次）
• 对于大数组，array.slice+splice（H）是Firefox和Safari最快的不可变解决方案；Array.from（B）是Chrome最快的
• 可变解决方案通常比不可变解决方案快1.5x-6倍
• 对于Safari上的小表，可变解（C）比不可变解（G）慢

详情

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

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

Chromearray.splice（C）是最快的就地解决方案。array.filter（D）是最快的不可变解决方案。最慢的是array.slice（F）。您可以在机器这里上执行测试。

具有1.000.000个元素的数组的结果

Chromearray.splice（C）是最快的就地解决方案（delete（C）的速度类似-但它在数组中留下了一个空槽（因此它不会执行'完全删除'））。array.slice-splice（H）是最快的不可变解决方案。最慢的是array.filter（D和E）。您可以在机器这里上执行测试。

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 does not perform tests itself.

Comparison for browsers: Chrome v78.0.0, Safari v13.0.4, and Firefox v71.0.0

从数组中删除特定元素可以使用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

您可以使用splice从数组中删除对象或值。

让我们考虑一个长度为5的数组，值为#1，#2，#3，#4，#5，我想从中删除值#3。

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]

我发现这篇博客文章展示了九种方法：

从JavaScript数组中删除元素的9种方法-以及如何安全地清除JavaScript数组

我更喜欢使用filter()：

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

您可以使用

Array.splice(index);

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

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

注意：-过滤器不会更改原始数组；相反，它会创建一个新数组。

所以再次分配很重要。

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

ES10

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

1.一般案件

1.1。使用.splice()按值删除数组元素

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

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

// With a 'for' loopconst 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() methodconst 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()方法删除Array元素

|就地：否|
|删除重复项：是|
|按价值/指数：按值|

通过提供过滤函数，特定元素可以是数组中的过滤掉。然后为数组中的每个元素调用此类函数。

const value = 3let 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的原型可以使用其他方法进行扩展。然后可以在创建的数组上使用这些方法。

备注：从JavaScript标准库（如Array）扩展对象原型被一些人视为反模式。

// In-place, removes all, by value implementationArray.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 implementationArray.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运算符删除Array元素

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

使用删除运算符不会影响长度属性。它也不会影响后续元素的索引。数组变得稀疏，这是一种奇特的方式，表示已删除的项目未被删除但变得未定义。

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

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

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

|就地：否|
|删除重复项：是|
|按价值/指数：按价值|

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

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|

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

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

2.1.2.使用.pop()方法

|就地：是|
|删除重复项：否|
|按价值/指数： N/A|

pop方法删除数组的最后一个元素，返回该元素，并更新长度属性。pop方法修改调用它的数组，这意味着与使用删除不同，最后一个元素被完全删除，数组长度减少。

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

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

|就地：是|
|删除重复项：否|
|按价值/指数： N/A|

.shift()方法的工作方式与pop方法非常相似，只是它删除了JavaScript数组的第一个元素而不是最后一个元素。当元素被删除时，剩余的元素会向下移动。

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

2.3.如果元素是数组中的唯一元素，则删除它

|就地：是|
|删除重复项： N/A|
|按价值/指数： N/A|

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

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

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

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

一种不可变的单行方式：

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

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

这里有两个场景：

1. 我们知道索引

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

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

   const drinks =  ['Tea','Coffee', 'Milk'];const id = drinks.indexOf('Coffee'); // 1const 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);

在ES6中，设置集合提供了删除方法来从数组中删除特定值，然后通过点差算子将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']

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

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

plice（）函数能够返回数组中的一个项目，并从特定索引中删除一个或多个项目：

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

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

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函数。它迭代所有数组项，并仅返回满足箭头函数的项。因此，旧数组保持不变，而名为result的新数组包含所有不等于5的项。您可以自己测试在线。

您可以像这样可视化array.prototype.filter：

考虑因素

代码质量

在这种情况下，Array.prototype.filter是删除数字的最可读方法。它几乎没有错误的地方，并使用核心JS功能。

为什么不array.prototype.map？

对于该用例，Array.prototype.map有时被认为是array.prototype.filter的替代方案。但它不应该被使用。原因是array.prototype.filter在概念上用于满足箭头函数的筛选项（正是我们需要的），而array.prototype.map用于转换项。由于我们在迭代项目时不会更改项目，因此正确的使用函数是array.prototype.filter。

支持

截至今天（11.4.2022）94.08%的互联网用户浏览器支持array.prototype.filter.因此，一般来说，使用它是安全的。然而，IE6-8不支持它。因此，如果您的用例需要支持这些浏览器，Chris Ferdinanti提出了一个不错的聚填充。

性能

Array.prototype.filter对于大多数用例来说都很棒。但是，如果您正在寻找高级数据处理的一些性能改进，您可以探索一些其他选择，例如使用纯for。另一个不错的选择是重新考虑您正在处理的数组是否真的必须这么大。这可能表明JavaScript应该从数据源接收一个简化的数组进行处理。

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

此函数从特定位置从数组中删除元素。

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

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

var num = [5, 6, 5, 4, 5, 1, 5];
var result1 = num.filter((el, index) => el != 5) // for remove all 5var result2 = num.filter((el, index) => index != 5) // for remove item with index == 5
console.log(result1);console.log(result2);

使用过滤器是实现此要求的优雅方式。filter不会改变原始数组。

const num = 3;let arr = [1, 2, 3, 4];const arr2 = arr.filter(x => x !== num);console.log(arr); // [1, 2, 3, 4]console.log(arr2); // [1, 2, 4]

如果您想实现突变删除行为，您可以使用filter，然后将结果分配给原始数组。

const num = 3;let arr = [1, 2, 3, 4];arr = arr.filter(x => x !== num);console.log(arr); // [1, 2, 4]

顺便说一句，filter将删除条件中匹配的所有出现（不仅仅是第一次出现），就像你在下面的例子中看到的那样

const num = 3;let arr = [1, 2, 3, 3, 3, 4];arr = arr.filter(x => x !== num);console.log(arr); // [1, 2, 4]

如果您只想删除第一个匹配项，可以使用拼接方法

const num = 3;let arr = [1, 2, 3, 3, 3, 4];arr.splice(arr.indexOf(num), 1);console.log(arr); // [1, 2, 3, 3, 4]

有很多方法可以从JavaScript数组中获得删除特定元素。以下是我在研究中提出的5种最佳可用方法。

1.直接使用'schice（）'方法

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

• 语法：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.使用“plice（）”方法按“value”删除元素

在下面的代码段中，我们可以使用进行循环中的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 removedconsole.log("Removed elements: " + removed);

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

类似于使用'plice（）'方法的实现，但它不是改变现有数组，而是创建一个新的元素数组，其中删除了不需要的元素。

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库中使用'删除（）'方法

在下面的代码段中，JavaScript库中有一个名为“Lodash”的删除（）方法。此方法也类似于filter方法。

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. making a custom remove method

There is no native 'array.remove' method in JavaScript, but we can create one using above methods we used as implemented in the following code snippet.

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

最后一种方法（第5种）更适合解决上述问题。

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

Array.prototype.remove = function(x){return this.filter(function(v){return v !== x;});};
var a = ["a","b","c"];var b = a.remove('a');

我喜欢这首单曲：

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

• ES6（无Internet Explorer支持）
• 移除就地完成。
• 快速：没有多余的迭代或重复。
• 支持删除null或undefined等值

作为原型

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

（是的，我读了所有其他的答案，找不到一个在同一行中结合了includes和splice的答案。

我测试了#0和#1，看看哪个更快：

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在逻辑上更清晰（更容易阅读），更适合使用不可变状态的编码风格。所以你是否想做出这种权衡取决于你。

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

使用数组过滤器方法：

let array = [1, 2, 3, 4, 511, 34, 511, 78, 88];
let value = 511;array = array.filter(element => element !== value);console.log(array)

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

您可以添加一个原型函数来从数组中“删除”元素。

下面的示例显示了当我们知道元素的索引时，如何简单地从数组中删除元素。我们在#0方法中使用它。

Array.prototype.removeByIndex = function(i) {if(!Number.isInteger(i) || i < 0) {// i must be an integerreturn this;}
return this.filter((f, indx) => indx !== i)}var a = [5, -89, (2 * 2), "some string", null, false, undefined, 20, null, 5];
var b = a.removeByIndex(2);console.log(a);console.log(b);

有时我们不知道元素的索引。

Array.prototype.remove = function(i) {return this.filter(f => f !== i)}var a = [5, -89, (2 * 2), "some string", null, false, undefined, 20, null, 5];
var b = a.remove(5).remove(null);console.log(a);console.log(b);
// It removes all occurrences of searched value

但是，当我们只想删除搜索值的第一个匹配项时，我们可以在函数中使用#0方法。

Array.prototype.removeFirst = function(i) {i = this.indexOf(i);
if(!Number.isInteger(i) || i < 0) {return this;}
return this.filter((f, indx) => indx !== i)}var a = [5, -89, (2 * 2), "some string", null, false, undefined, 20, null, 5];
var b = a.removeFirst(5).removeFirst(null);console.log(a);console.log(b);

 (function removeFromArrayPolyfill() {if (window.Array.prototype.remove) return;    
Array.prototype.remove = function (value) {if (!this.length || !value) return;    
const indexOfValue = this.indexOf(value);    
if (indexOfValue >= 0) {this.splice(indexOfValue, 1);}};})();    
// testing polyfillconst nums = [10, 20, 30];nums.remove(20);console.log(nums);//[10,30]

您可以使用Set代替并使用delete函数：

const s = Set;s.add('hello');s.add('goodbye');s.delete('hello');

1. 获取数组和索引
2. 从带有数组元素的数组列表
3. 使用remove()方法删除特定的索引元素
4. 使用maptoint()和toarray()方法从数组列表的新数组
5. 返回格式化数组

这取决于你是否想保留一个空位。

如果你想要一个空的插槽：

array[index] = undefined;

如果你不想要一个空的插槽：

保留原件：

oldArray = [...array];

这将修改数组。

array.splice(index, 1);

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

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

如果要删除数组的任何一端，可以对最后一个使用array.pop（），对第一个使用array.shift（）（两者都返回项的值）。

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

Lodash：

let a1 = {name:'a1'}let a2 = {name:'a2'}let a3 = {name:'a3'}let list = [a1, a2, a3]_.remove(list, a2)//list now is [{name: "a1"}, {name: "a3"}]

查看详情：.identity]）