1个
2
3
4
下一个
使用indexOf查找要删除的数组元素的索引，然后使用splice删除该索引。
splice（）方法通过删除来更改数组的内容
现有元素和/或添加新元素。
const array = [2，5，9];
console.log（array）;
const index = array.indexOf（5）;
如果（索引> -1）{
array.splice（index，1）;
}
//数组= [2，9]
console.log（array）;
拼接的第二个参数是要删除的元素数。请注意，splice修改了该数组并返回一个包含已删除元素的新数组。
出于完整性的原因，这里有一些功能。第一个函数仅删除一个匹配项（即从[2,5,9,1,5,8,5]中删除第一个匹配项5），而第二个函数则删除所有匹配项：
函数removeItemOnce（arr，value）{
var index = arr.indexOf（value）;
如果（索引> -1）{
arr.splice（index，1）;
}
返回arr;
}
函数removeItemAll（arr，value）{
var i = 0;
而（i = 0; i--）{
如果（array [i] ===数字）{
array.splice（i，1）;
}
}
如果您只想使索引i处的元素不再存在，但又不想更改其他元素的索引：
删除数组[i];
|
于2016年10月编辑
做到简单，直观和明确（Occam的剃刀）
做到一成不变（原始数组保持不变）
如果您的浏览器不支持标准JavaScript函数，请执行此操作-使用polyfill
在此代码示例中，我使用“ array.filter（...）”函数从数组中删除不需要的项。此函数不会更改原始数组，而是创建一个新数组。如果您的浏览器不支持此功能（例如，版本9之前的Internet Explorer或版本1.5之前的Firefox），请考虑使用Mozilla中的过滤器polyfill。
删除项目（ECMA-262版本5代码又称为旧式JavaScript）
变量值= 3
var arr = [1、2、3、4、5、3]
arr = arr.filter（function（item）{
返回项目！==值
}）
console.log（arr）
// [1，2，4，5]
删除项目（ECMAScript 6代码）
令值= 3
令arr = [1、2、3、4、5、3]
arr = arr.filter（item =>项目！==值）
console.log（arr）
// [1，2，4，5]
重要信息ECMAScript 6的（（）=> {}''箭头函数语法在Internet Explorer，45之前的Chrome，22之前的Firefox和10之前的Safari中完全不受支持。要在旧版浏览器中使用ECMAScript 6语法，可以使用BabelJS。
删除多个项目（ECMAScript 7代码）
此方法的另一个优点是您可以删除多个项目
让forDeletion = [2，3，5]
令arr = [1、2、3、4、5、3]
arr = arr.filter（item =>！forDeletion.includes（item））
// !!!在下面阅读有关array.includes（...）的支持！！！
console.log（arr）
// [1，4]
重要信息``array.includes（...）''功能完全不受Internet Explorer，47之前的Chrome，43之前的Firefox，9之前的Safari和14之前的Edge的支持，因此这是Mozilla的polyfill。
删除多个项目（将来可能）
如果“此绑定语法”提议曾经被接受，则可以执行以下操作：
// array-lib.js
导出函数remove（... forDeletion）{
返回this.filter（item =>！forDeletion.includes（item））
}
// main.js
从'./array-lib.js'导入{删除}
令arr = [1、2、3、4、5、3]
// ::此绑定语法建议
//将“删除”功能用作“虚拟方法”
//不扩展Array.prototype
arr = arr :: remove（2，3，5）
console.log（arr）
// [1，4]
在BabelJS中自己尝试：)
参考
Array.prototype.includes
功能组成
|
这取决于您是否要保留空白位置。
如果您确实想要一个空插槽：
array [index] =未定义；
如果您不想留空的插槽：
//保留原始内容：
// oldArray = [... array];
//这将修改数组。
array.splice（index，1）;
而且，如果您需要该项目的值，则可以只存储返回的数组的元素：
var值= array.splice（index，1）[0];
如果要删除数组的任一端，则可以对最后一个数组使用array.pop（）或对第一个数组使用array.shift（）（也都返回该项的值）。
如果您不知道该项目的索引，则可以使用array.indexOf（item）来获取它（在if（）中获取一个项目，或者在while（）中获取所有它们）。 array.indexOf（item）返回索引或-1（如果找不到）。
|
一位朋友在Internet Explorer 8中遇到问题，向我展示了他的所作所为。我告诉他这是错误的，他告诉我他得到了答案这里。当前的最佳答案不适用于所有浏览器（例如Internet Explorer 8），并且只会删除该项目的首次出现。
从阵列中删除所有实例
函数array_remove_index_by_value（arr，item）
{
对于（var i = arr.length; i--;）
{
if（arr [i] === item）{arr.splice（i，1）;}
}
}
它向后循环遍历数组（因为索引和长度会随着项目的删除而改变），并在找到后删除该项目。它适用于所有浏览器。
|
有两种主要方法：
splice（）：anArray.splice（index，1）;
delete：删除anArray [index];
对数组使用delete时要小心。这对删除对象的属性很有用，但对数组却不太好。最好对数组使用拼接。
请记住，当对数组使用delete时，anArray.length可能会得到错误的结果。换句话说，delete会删除该元素，但不会更新length属性的值。
您还可以期望在使用删除操作后索引号中出现漏洞，例如您最终可能会拥有使用delete之前的索引1、3、4、8、9和11，以及长度。在这种情况下，所有索引的for循环都会崩溃，因为索引不再是顺序的。
如果由于某种原因而被迫使用delete，那么当您需要遍历数组时，应该为每个循环使用delete。实际上，如果可能，请始终避免使用索引for循环。这样，代码将更健壮，并且不易出现索引问题。
|
Array.prototype.remove_by_value = function（val）{
for（var i = 0; i row.id === 5）;
var remove = helper.remove（arr，row => row.name.startsWith（'BMW'））;
＃＃定义
var helper = {
//删除并返回第一个匹配项
removeOne：函数（数组，谓词）{
for（var i = 0; i [2，3，4]
|
您可以使用ES6。例如，在这种情况下删除值“ 3”：
var array = ['1'，'2'，'3'，'4'，'5'，'6']
var newArray = array.filter（（value）=> value！='3'）;
console.log（newArray）;
输出：
[“ 1”，“ 2”，“ 4”，“ 5”，“ 6”]
|
如果要删除已删除位置的新数组，则始终可以删除特定元素并过滤掉该数组。对于未实现filter方法的浏览器，可能需要扩展array对象，但是从长远来看，这很容易，因为您要做的就是：
var my_array = [1,2,3,4,5,6];
删除my_array [4];
console.log（my_array.filter（function（a）{返回类型的！=='undefined';}）））;
它应该显示[1、2、3、4、6]。
|
这是使用JavaScript从数组中删除项目的几种方法。
所描述的所有方法都不会改变原始数组，而是创建一个新数组。
如果您知道项目的索引
假设您有一个数组，并且想要删除位置i处的项目。
一种方法是使用slice（）：
const项目= ['a'，'b'，'c'，'d'，'e'，'f']
const i = 3
constfilteredItems = items.slice（0，i）.concat（items.slice（i + 1，items.length））
console.log（filteredItems）
slice（）使用接收到的索引创建一个新数组。我们只需创建一个新数组，即从开始到要删除的索引，然后从第一个位置开始连接另一个数组，该位置在我们删除的数组之后到数组的结尾。
如果你知道价值
在这种情况下，一个不错的选择是使用filter（），它提供了一种更具声明性的方法：
const项目= ['a'，'b'，'c'，'d'，'e'，'f']
const valueToRemove ='c'
constfilteredItems = items.filter（item => item！== valueToRemove）
console.log（filteredItems）
这将使用ES6箭头功能。您可以使用传统功能来支持较旧的浏览器：
const项目= ['a'，'b'，'c'，'d'，'e'，'f']
const valueToRemove ='c'
constfilteredItems = items.filter（function（item）{
返回项目！== valueToRemove
}）
console.log（filteredItems）
或者，您可以使用Babel并将ES6代码重新编译回ES5，以使其更易于被旧的浏览器使用，但仍可以在代码中编写现代的JavaScript。
删除多个项目
如果要删除多个项目而不是单个项目怎么办？
让我们找到最简单的解决方案。
按索引
您可以只创建一个函数并删除一系列项目：
const项目= ['a'，'b'，'c'，'d'，'e'，'f']
const removeItem =（items，i）=>
items.slice（0，i-1）.concat（items.slice（i，items.length））
让filteredItems = removeItem（items，3）
filteredItems = removeItem（filteredItems，5）
//[“A B C D”]
console.log（filteredItems）
按价值
您可以在回调函数中搜索包含项：
const项目= ['a'，'b'，'c'，'d'，'e'，'f']
const valuesToRemove = ['c'，'d']
constfilteredItems = items.filter（item =>！valuesToRemove.includes（item））
// [[a]，“ b”，“ e”，“ f”]
console.log（filteredItems）
避免改变原始数组
splice（）（不要与slice（）混淆）会变异原始数组，应避免使用。
（最初发布在我的网站https://flaviocopes.com/how-to-remove-item-from-array/）
|
查看此代码。它适用于所有主流浏览器。
remove_item = function（arr，value）{
var b ='';
为（b in arr）{
if（arr [b] === value）{
arr.splice（b，1）;
打破;
}
}
返回arr;
};
调用此功能
remove_item（array，value）;
|
ES6且无突变：（2016年10月）
const removeByIndex =（列表，索引）=>
[
... list.slice（0，index），
... list.slice（索引+1）
];
输出= removeByIndex（[33,22,11,44]，1）// => [33,11,44]
console.log（输出）
|
您可以使用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']
|
从数组中删除特定的元素/字符串可以用一种方法完成：
theArray.splice（theArray.indexOf（“ stringToRemoveFromArray”），1）;
哪里：
theArray：要从中删除特定内容的数组
stringToRemoveFromArray：要删除的字符串，1是要删除的元素数量。
注意：如果“ stringToRemoveFromArray”不在数组中，则将删除数组的最后一个元素。
在删除元素之前，先检查该元素是否存在于数组中始终是一个好习惯。
如果（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'）;
其中“ 3”是要从数组中删除的值。
数组将变为：['1'，'2'，'4'，'5'，'6']
|
好的，例如，您具有以下数组：
var num = [1,2,3,4,5];
我们要删除数字4。您可以简单地使用以下代码：
num.splice（num.indexOf（4），1）; // num为[1、2、3、5];
如果要重用此函数，请编写一个可重用的函数，该函数将附加到本机数组函数，如下所示：
Array.prototype.remove = Array.prototype.remove ||函数（x）{
const i = this.indexOf（x）;
如果（i ===-1）
返回;
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）//返回[1、2、3、4、6]
此外，还有第三方库（例如Lodash或Underscore）可以帮助您完成此任务。有关更多信息，请查看lodash _.pull，_。pullAt或_.without。
|
性能
今天（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.5到6倍
对于Safari上的小表，令人惊讶的是，可变解决方案（C）比不可变解决方案（G）慢
细节
在测试中，我以不同的方式从数组中删除了中间元素。 A，C解决方案就位。 B，D，E，F，G，H解决方案是不可变的。
包含10个元素的数组的结果
在Chrome中，array.splice（C）是最快的就地解决方案。 array.filter（D）是最快的不可变解决方案。最慢的是array.slice（F）。您可以在此处在计算机上执行测试。
包含1.000.000元素的数组的结果
在Chrome中，array.splice（C）是最快的就地解决方案（删除（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`，`）;
函数A（数组）{
var index = array.indexOf（5）;
删除数组[索引];
log（'A'，array）;
}
函数B（数组）{
var index = array.indexOf（5）;
var arr = Array.from（array）;
arr.splice（索引，1）
log（'B'，arr）;
}
函数C（array）{
var index = array.indexOf（5）;
array.splice（index，1）;
log（'C'，array）;
}
函数D（array）{
var arr = array.filter（item => item！== 5）
log（'D'，arr）;
}
函数E（array）{
var index = array.indexOf（5）;
var arr = array.filter（（item，i）=> i！==索引）
log（'E'，arr）;
}
函数F（array）{
var index = array.indexOf（5）;
var arr = array.slice（0，index）.concat（array.slice（index +1））
log（'F'，arr）;
}
函数G（array）{
var index = array.indexOf（5）;
var arr = [... array.slice（0，index），... array.slice（index + 1）]
log（'G'，arr）;
}
函数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]）;
哈]）;
此代码段仅显示性能测试中使用的代码-本身不执行测试。
浏览器比较：Chrome v78.0.0，Safari v13.0.4和Firefox v71.0.0
|
我对JavaScript很陌生，需要此功能。我只是这样写：
函数removeFromArray（array，item，index）{
while（（（index = array.indexOf（item））> -1）{
array.splice（index，1）;
}
}
然后，当我想使用它时：
//设置一些虚拟数据
var dummyObj = {name：“喵”};
var dummyArray = [dummyObj，“ item1”，“ item1”，“ item2”];
//删除虚拟数据
removeFromArray（dummyArray，dummyObj）;
removeFromArray（dummyArray，“ item2”）;
输出-如预期。
[“ item1”，“ item1”]
您可能与我有不同的需求，因此可以轻松对其进行修改适合他们。我希望这可以帮助别人。
|
如果数组中有复杂的对象，可以使用过滤器吗？
在$ .inArray或array.splice不那么容易使用的情况下。特别是如果对象在数组中可能很浅。
例如。如果您有一个具有ID字段的对象，并且希望将该对象从数组中删除：
this.array = this.array.filter（function（element，i）{
返回element.id！== idToRemove;
}）;
|
我想根据ECMAScript 6进行回答。假设您有一个如下数组：
令arr = [1,2,3,4];
如果要删除像2这样的特殊索引，请编写以下代码：
arr.splice（2，1）; // => arr变为[1,2,4]
但是，如果您要删除特殊项目（例如3）并且不知道其索引，请执行以下操作：
arr = arr.filter（e => e！== 3）; // => arr变为[1,2,4]
提示：请使用箭头函数进行过滤器回调，除非您得到一个空数组。
|
更新：仅当您无法使用ECMAScript 2015（以前称为ES6）时，才建议使用此方法。如果可以使用它，此处的其他答案将提供更整洁的实现。
这里的要点将解决您的问题，并删除所有出现的参数，而不仅仅是1（或指定值）。
Array.prototype.destroy = function（obj）{
//如果未找到并删除任何对象，则返回null
var destroy = null;
for（var i = 0; i 3
x.destroy（false）; // =>否
X; // => [1,2，true，undefined]
x.destroy（true）; // =>是
x.destroy（未定义）; // =>未定义
X; // => [1，2]
x.destroy（3）; // => null
X; // => [1，2]
|
ES10更新
这篇文章总结了自ECMAScript 2019（ES10）起从数组中删除元素的常用方法。
1.一般情况
1.1。使用.splice（）按值删除Array元素
|就地：是|
|删除重复项：是（循环），否（indexOf）|
|按值/索引：按索引|
如果知道要从数组中删除的值，则可以使用splice方法。首先，您必须确定目标项目的索引。然后，您将索引用作开始元素，并仅删除一个元素。
//使用“ for”循环
const arr = [1,2,3,4,5,6,7,8,9,0];
for（令i = 0; i <长度; i ++）{
如果（arr [i] === 5）{
arr.splice（i，1）;
}
} // => [1、2、3、4、6、7、8、9、0]
//使用.indexOf（）方法
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（）方法删除Array元素
|就地：否|
|删除重复项：是|
|按值/索引：按值|
通过提供过滤功能，可以从数组中过滤出特定元素。然后为数组中的每个元素调用此函数。
常量值= 3
令arr = [1、2、3、4、5、3]
arr = arr.filter（item =>项目！==值）
console.log（arr）
// [1，2，4，5]
1.3。通过扩展Array.prototype删除Array元素
|就地：是/否（取决于实现）|
|删除重复项：是/否（取决于实现）|
|按值/索引：按索引/按值（取决于实现）|
Array的原型可以使用其他方法扩展。这样，这些方法将可用于创建的数组。
注意：从标准的JavaScript库（例如Array）扩展对象的原型被认为是一种反模式。
//通过值实现就地删除所有内容
Array.prototype.remove = function（item）{
for（让i = 0; i = ES10）删除数组元素
|就地：否|
|删除重复项：是|
|按值/索引：按值|
ES10引入了Object.fromEntries，可以是用于从任何类似Array的对象创建所需的Array并在此过程中过滤不需要的元素。
const object = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values（Object.fromEntries（
Object.entries（对象）
.filter（（[[key，val]）=> val！== valueToRemove）
））;
console.log（arr）; // [1,2,4]
2.特殊情况
2.1如果元素在数组的末尾，则将其删除
2.1.1。更改数组长度
|就地：是|
|删除重复项：否|
|按值/索引：N / A |
通过将length属性设置为小于当前值的值，可以从数组的末尾删除JavaScript Array元素。索引大于或等于新长度的任何元素都将被删除。
const arr = [1,2,3,4,5,6];
arr.length = 5; //设置删除元素的长度
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（）; //返回6
console.log（arr）; // [1、2、3、4、5]
2.2。如果元素在数组的开头，则将其删除
|就地：是|
|删除重复项：否|
|按值/索引：N / A |
.shift（）方法的工作原理与pop方法非常相似，只是它删除了JavaScript数组的第一个元素而不是最后一个元素。删除元素后，其余元素将向下移动。
const arr = [1,2,3,4];
arr.shift（）; //返回1
console.log（arr）; // [2，3，4]
2.3。如果元素是数组中的唯一元素，则将其删除
|就地：是|
|删除重复项：N / A |
|按值/索引：N / A |
最快的技术是将数组变量设置为空数组。
令arr = [1];
arr = []; //空数组
通过将长度设置为0，可以使用2.1.1中的替代技术。
|
您绝对不应更改数组。因为这与功能编程模式相反。您可以使用ECMAScript 6方法过滤器创建一个新数组而不引用要更改数据的数组;
var myArray = [1,2,3,4,5,6];
假设您要从数组中删除5，您可以像这样简单地进行操作：
myArray = myArray.filter（值=>值！== 5）;
这将为您提供一个没有要删除的值的新数组。因此结果将是：
[1、2、3、4、6]； //已从该数组中删除5
为了进一步理解，您可以阅读Array.filter上的MDN文档。
|
一种更现代的ECMAScript 2015（以前称为Harmony或ES 6）方法。鉴于：
const项目= [1、2、3、4]；
const index = 2;
然后：
items.filter（（x，i）=> i！==索引）;
屈服：
[1、2、4]
您可以使用Babel和polyfill服务来确保所有浏览器都很好地支持此功能。
|
如果该元素存在多个实例，则可以进行向后循环以确保不破坏索引。
var myElement =“巧克力”;
var myArray = ['chocolate'，'poptart'，'poptart'，'poptart'，'chocolate'，'poptart'，'poptart'，'chocolate']；
/ *重要代码* /
for（var i = myArray.length-1; i> = 0; i--）{
如果（myArray [i] == myElement）myArray.splice（i，1）;
}
console.log（myArray）;
现场演示
|
您的数组中有1到9，并且要删除5。使用以下代码：
var numberArray = [1、2、3、4、5、6、7、8、9]；
var newNumberArray = numberArray.filter（m => {
返回m！== 5;
}）;
console.log（“新数组，已删除5个”，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（“新数组，删除1,7和8”，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（“删除新数组[[3,4,5]”，newNumberArray）;
包括支持的浏览器链接。
|
1个
2
3
4
下一个
高度活跃的问题。赢得10个声誉才能回答这个问题。信誉要求有助于保护该问题免受垃圾邮件和非答复活动的侵害。
不是您要找的答案？浏览其他标记有javascript数组的问题，或提出您自己的问题。