是否有从JavaScript数组中删除项目的方法？
给定一个数组：
var ary = ['three', 'seven', 'eleven'];
我想做点什么：
removeItem('seven', ary);
我调查了splice()，但只删除了位置编号，而我需要通过其值删除项目。
答案 0 :(得分：1320)
您可以像这样使用indexOf method：
var index = array.indexOf(item);
if (index !== -1) array.splice(index, 1);
var array = [1,2,3,4]
var item = 3
var index = array.indexOf(item);
if (index !== -1) array.splice(index, 1);
console.log(array)
答案 1 :(得分：435)
如果不允许添加到本机原型，则可以是全局函数或自定义对象的方法。它会从数组中删除与任何参数匹配的所有项目。
Array.prototype.remove = function() {
var what, a = arguments, L = a.length, ax;
while (L && this.length) {
what = a[--L];
while ((ax = this.indexOf(what)) !== -1) {
this.splice(ax, 1);
}
}
return this;
};
var ary = ['three', 'seven', 'eleven'];
ary.remove('seven');
/* returned value: (Array)
three,eleven
*/
使其成为全球性的 -
function removeA(arr) {
var what, a = arguments, L = a.length, ax;
while (L > 1 && arr.length) {
what = a[--L];
while ((ax= arr.indexOf(what)) !== -1) {
arr.splice(ax, 1);
}
}
return arr;
}
var ary = ['three', 'seven', 'eleven'];
removeA(ary, 'seven');
/* returned value: (Array)
three,eleven
*/
并照顾IE8及以下 -
if(!Array.prototype.indexOf) {
Array.prototype.indexOf = function(what, i) {
i = i || 0;
var L = this.length;
while (i < L) {
if(this[i] === what) return i;
++i;
}
return -1;
};
}
答案 2 :(得分：318)
单行将会这样做，
var ary = ['three', 'seven', 'eleven'];
// Remove item 'seven' from array
var filteredAry = ary.filter(function(e) { return e !== 'seven' })
//=> ["three", "eleven"]
// In ECMA6 (arrow function syntax):
var filteredAry = ary.filter(e => e !== 'seven')
这使用了JS中的filter函数。它在IE9及更高版本中得到支持。
它的作用（来自文档链接）
filter（）为数组中的每个元素调用一次提供的回调函数，并构造一个包含所有值的新数组，其中回调返回一个强制为true的值。仅为已分配值的数组的索引调用回调;对于已删除的索引或从未分配过值的索引，不会调用它。不会通过回调测试的数组元素被简单地跳过，并且不包含在新数组中。
基本上，这与所有其他for (var key in ary) { ... }解决方案相同，只是从IE6开始支持for in结构。
基本上，过滤器是一种方便的方法，与for in构造（AFAIK）相比，它看起来更好（并且是可链接的）。
答案 3 :(得分：131)
您可以使用underscore.js。这真的很简单。
例如，有了这个：
var result = _.without(['three','seven','eleven'], 'seven');
result将是['three','eleven']。
在您的情况下，您必须编写的代码是：
ary = _.without(ary, 'seven')
它减少了你编写的代码。
答案 4 :(得分：50)
以这种方式检查：
for(var i in array){
if(array[i]=='seven'){
array.splice(i,1);
break;
}
}
并且在一个函数中：
function removeItem(array, item){
for(var i in array){
if(array[i]==item){
array.splice(i,1);
break;
}
}
}
removeItem(array, 'seven');
答案 5 :(得分：35)
这是一个使用jQuery的inArray function：
的版本var index = $.inArray(item, array);
if (index != -1) {
array.splice(index, 1);
}
答案 6 :(得分：29)
您可以通过以下两种方式实现：
var arr = ["1","2","3","4"] // we wanna delete number "3"
第一
arr.indexOf('3') !== -1 && arr.splice(arr.indexOf('3'), 1)
秒（ES6）：
arr = arr.filter(e => e !== '3')
答案 7 :(得分：27)
var index = array.indexOf('item');
if(index!=-1){
array.splice(index, 1);
}
答案 8 :(得分：19)
您可以创建自己的方法，在数组和要删除的值之间传递：
ary = removeItem(ary, 'seven');
然后您可以通过以下方式调用它：
let retValue = {};
yourarray.forEach(item=>{retValue[item]=item});
console.log([retValue]);
答案 9 :(得分：16)
您所追求的是过滤器
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
这将允许您执行以下操作：
var ary = ['three', 'seven', 'eleven'];
var aryWithoutSeven = ary.filter(function(value) { return value != 'seven' });
console.log(aryWithoutSeven); // returns ['three', 'eleven']
在其他地方的这个帖子中也注意到了这一点：https://stackoverflow.com/a/20827100/293492
答案 10 :(得分：11)
看到没有漂亮的，这是一个简单且可重复使用的ES6功能。
const removeArrayItem = (arr, itemToRemove) => {
return arr.filter(item => item !== itemToRemove)
}
用法：
const items = ['orange', 'purple', 'orange', 'brown', 'red', 'orange']
removeArrayItem(items, 'orange')
答案 11 :(得分：9)
如果您的数组中有唯一值且订购无关紧要，您可以使用设置，并且删除：
var mySet = new Set(['foo']);
mySet.delete('foo'); // Returns true. Successfully removed.
mySet.has('foo'); // Returns false. The "foo" element is no longer present.
答案 12 :(得分：9)
ES6方式。
const commentsWithoutDeletedArray = commentsArray.filter(comment => comment.Id !== commentId);
答案 13 :(得分：9)
简单
var ary = ['three', 'seven', 'eleven'];
var index = ary.indexOf('seven'); // get index if value found otherwise -1
if (index > -1) { //if found
ary.splice(index, 1);
}
答案 14 :(得分：8)
真的，我看不到为什么不能用
解决arr = arr.filter(value => value !== 'seven');
或者也许您想使用香草JS
arr = arr.filter(function(value) { return value !== 'seven' });
答案 15 :(得分：7)
从数组中删除所有匹配的元素（而不仅仅是第一个，这似乎是最常见的答案）：
while ($.inArray(item, array) > -1) {
array.splice( $.inArray(item, array), 1 );
}
我使用jQuery进行繁重的工作，但如果你想成为原生人，你就会明白。
答案 16 :(得分：6)
在所有浏览器中运行并且没有任何框架的非常干净的解决方案是设置一个新数组，只需返回它而不需要删除项目：
/**
* @param {Array} array the original array with all items
* @param {any} item the time you want to remove
* @returns {Array} a new Array without the item
*/
var removeItemFromArray = function(array, item){
/* assign a empty array */
var tmp = [];
/* loop over all array items */
for(var index in array){
if(array[index] !== item){
/* push to temporary array if not like item */
tmp.push(array[index]);
}
}
/* return the temporary array */
return tmp;
}
答案 17 :(得分：6)
最简单的解决方案是：
array-用于删除某些元素valueForRemove的数组； valueForRemove-删除元素；
array.filter(arrayItem => !array.includes(valueForRemove));
更简单：
array.filter(arrayItem => arrayItem !== valueForRemove);
答案 18 :(得分：4)
您可以使用 Lodash _.remove函数来实现。
var array = ['three', 'seven', 'eleven'];
var evens = _.remove(array, function(e) {
return e !== 'seven';
});
console.log(evens);<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/lodash@4.17.10/lodash.min.js"></script>
答案 19 :(得分：4)
indexOf是一个选项，但它的实现基本上是在整个数组中搜索值，因此执行时间会随着数组大小而增加。 （所以我猜这是在每个浏览器中，我只检查过Firefox）。
我还没有检查IE6，但我称之为安全的赌注，你几乎可以在任何一台客户端计算机上每秒检查至少一百万个数组项目。如果[数组大小] * [每秒搜索量]可能增长超过一百万，您应该考虑不同的实现。
基本上，您可以使用对象为数组创建索引，如下所示：
var index={'three':0, 'seven':1, 'eleven':2};
任何理智的JavaScript环境都会为这些对象创建一个可搜索的索引，这样无论对象有多少属性，您都可以快速将键转换为值。
这只是基本方法，根据您的需要，您可以组合多个对象和/或数组，以便快速搜索不同属性的相同数据。如果您指定了确切的需求，我可以建议更具体的数据结构。
答案 20 :(得分：4)
在所有唯一值中，您可以：
a = new Set([1,2,3,4,5]) // a = Set(5) {1, 2, 3, 4, 5}
a.delete(3) // a = Set(5) {1, 2, 4, 5}
[...a] // [1, 2, 4, 5]
答案 21 :(得分：3)
诀窍是从头到尾遍历数组，这样你就不会在删除元素时弄乱指数。
var deleteMe = function( arr, me ){
var i = arr.length;
while( i-- ) if(arr[i] === me ) arr.splice(i,1);
}
var arr = ["orange","red","black", "orange", "white" , "orange" ];
deleteMe( arr , "orange");
arr现在是[＆＃34;红色＆＃34;，＆＃34;黑色＆＃34;，＆＃34;白色＆＃34;]
答案 22 :(得分：3)
当你需要删除数组中多次出现的值时（例如[1,2,2,2,4,5,6]）。
function removeFrmArr(array, element) {
return array.filter(e => e !== element);
};
var exampleArray = [1,2,3,4,5];
removeFrmArr(exampleArray, 3);
// return value like this
//[1, 2, 4, 5]
您可以使用splice从数组中删除单个元素，但splice不能从数组中删除多个类似的元素。
function singleArrayRemove(array, value){
var index = array.indexOf(value);
if (index > -1) array.splice(index, 1);
return array;
}
var exampleArray = [1,2,3,4,5,5];
singleArrayRemove(exampleArray, 5);
// return value like this
//[1, 2, 3, 4, 5]
答案 23 :(得分：2)
非破坏性清除：
function removeArrayValue(array, value)
{
var thisArray = array.slice(0); // copy the array so method is non-destructive
var idx = thisArray.indexOf(value); // initialise idx
while(idx != -1)
{
thisArray.splice(idx, 1); // chop out element at idx
idx = thisArray.indexOf(value); // look for next ocurrence of 'value'
}
return thisArray;
}
答案 24 :(得分：2)
您可以使用Lodash中的header("location: $url);或without：
pull答案 25 :(得分：1)
我使用了投票最多的选项并创建了一个函数，它可以使用另一组不需要的单词来清理一个单词数组：
function cleanArrayOfSpecificTerms(array,unwantedTermsArray) {
$.each(unwantedTermsArray, function( index, value ) {
var index = array.indexOf(value);
if (index > -1) {
array.splice(index, 1);
}
});
return array;
}
要使用，请执行以下操作：
var notInclude = ['Not','No','First','Last','Prior','Next', 'dogs','cats'];
var splitTerms = ["call", "log", "dogs", "cats", "topic", "change", "pricing"];
cleanArrayOfSpecificTerms(splitTerms,notInclude)
答案 26 :(得分：1)
let arr = [5, 15, 25, 30, 35];
console.log(arr); //result [5, 15, 25, 30, 35]
let index = arr.indexOf(30);
if (index > -1) {
arr.splice(index, 1);
}
console.log(arr); //result [5, 15, 25, 35]
答案 27 :(得分：1)
请不要将变体与delete一起使用 - 它会在数组中形成一个漏洞，因为它不会在删除的项目后重新索引元素。
> Array.prototype.remove=function(v){
... delete this[this.indexOf(v)]
... };
[Function]
> var myarray=["3","24","55","2"];
undefined
> myarray.remove("55");
undefined
> myarray
[ '3', '24', , '2' ]
答案 28 :(得分：0)
您可以使用lodash pull function
var ary = ['three', 'seven', 'eleven'];
_.pull(ary, 'seven'); // ['three', 'eleven']
console.log(ary)<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.6.1/lodash.js"></script>
答案 29 :(得分：0)
//感谢MarcoCI感谢您的建议
试试这个：
function wantDelete(item, arr){
for (var i=0;i<arr.length;i++){
if (arr[i]==item){
arr.splice(i,1); //this delete from the "i" index in the array to the "1" length
break;
}
}
}
var goodGuys=wantDelete('bush', ['obama', 'bush', 'clinton']); //['obama', 'clinton']
希望这能帮到你
答案 30 :(得分：0)
在全局函数中，我们不能直接传递自定义值，但是有很多方法如下
var ary = ['three', 'seven', 'eleven'];
var index = ary.indexOf(item);//item: the value which you want to remove
//Method 1
ary.splice(index,1);
//Method 2
delete ary[index]; //in this method the deleted element will be undefined
答案 31 :(得分：0)
另一种变化：
if (!Array.prototype.removeArr) {
Array.prototype.removeArr = function(arr) {
if(!Array.isArray(arr)) arr=[arr];//let's be nice to people who put a non-array value here.. that could be me!
var that = this;
if(arr.length){
var i=0;
while(i<that.length){
if(arr.indexOf(that[i])>-1){
that.splice(i,1);
}else i++;
}
}
return that;
}
}
它又是一个循环中的indexOf（），但是假设要删除的数组相对于要清理的数组而言较小;每次删除都会缩短while循环。
答案 32 :(得分：0)
//This function allows remove even array from array
var removeFromArr = function(arr, elem) {
var i, len = arr.length, new_arr = [],
sort_fn = function (a, b) { return a - b; };
for (i = 0; i < len; i += 1) {
if (typeof elem === 'object' && typeof arr[i] === 'object') {
if (arr[i].toString() === elem.toString()) {
continue;
} else {
if (arr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) {
continue;
}
}
}
if (arr[i] !== elem) {
new_arr.push(arr[i]);
}
}
return new_arr;
}
使用
的示例var arr = [1, '2', [1 , 1] , 'abc', 1, '1', 1];
removeFromArr(arr, 1);
//["2", [1, 1], "abc", "1"]
var arr = [[1, 2] , 2, 'a', [2, 1], [1, 1, 2]];
removeFromArr(arr, [1,2]);
//[2, "a", [1, 1, 2]]
答案 33 :(得分：0)
CoffeeScript + jQuery变体：
arrayRemoveItemByValue = (arr,value) ->
r=$.inArray(value, arr)
unless r==-1
arr.splice(r,1)
# return
arr
console.log arrayRemoveItemByValue(['2','1','3'],'3')
它只删除一个，而不是全部。
答案 34 :(得分：0)
我尝试使用jbaron上面的函数方法，但发现我需要保留原始数组以供日后使用，并创建一个新的数组：
var newArray = referenceArray;
显然是通过引用而不是值创建的，因为当我从newArray中删除一个元素时，referenceArray也删除了它。所以我决定每次创建一个新数组：
function newArrRemoveItem(array, item, newArray){
for(var i = 0; i < array.length; i++) {
if(array[i]!=item){
newArray.push(array[i]);
}
}
}
然后我在另一个函数中使用它：
var vesselID = record.get('VesselID');
var otherVessels = new Array();
newArrRemoveItem(vesselArr,vesselID,otherVessels);
现在，vesselArr保持完整，而每次执行上面的代码时，otherVessels数组都包含除最新的vesselID元素以外的所有内容。
答案 35 :(得分：0)
以这种方式签出：
delete this.arrayName[this.arrayName.indexOf(value)];
参考：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete
答案 36 :(得分：0)
var remove = function(array, value) {
var index = null;
while ((index = array.indexOf(value)) !== -1)
array.splice(index, 1);
return array;
};