有没有从 JavaScript 数组中删除项目的方法？
给定一个数组：
var ary = ['three', 'seven', 'eleven'];
我想做这样的事情：
removeItem('seven', ary);
我已经查看了splice()，但它只删除了位置编号，而我需要一些东西来删除一个项目的值。
【问题讨论】：
Array.filter()
标签： javascript arrays
如果你有唯一的值并且顺序无关紧要，使用Set，它有delete()：
var mySet = new Set(['three', 'seven', 'eleven']);
mySet.delete('seven'); // Returns true, successfully removed
[...mySet]; // Returns ['three', 'eleven']
【讨论】：
您可以像这样使用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);
array.splice(index, 1);
console.log(array)【讨论】：
-1时循环它
-1不同的拼接，有数以百万计的选项，明智地选择jsperf.com/not-vs-gt-vs-ge/4
$.inArray而不是indexOf，这是跨浏览器兼容的。
您可以创建自己的方法，传递数组和要删除的值：
function removeItem(arr, item){
return arr.filter(f => f !== item)
}
然后你可以这样调用：
ary = removeItem(ary, 'seven');
【讨论】：
当您需要删除数组中多次出现的值时（例如 [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]
【讨论】：
removeFrmArr(exampleArray, 3);，当前代码会抛出 ReferenceError。
简单
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);
}
【讨论】：
这样查看：
delete this.arrayName[this.arrayName.indexOf(value)];
参考：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete
【讨论】：
您可以通过以下两种方式做到这一点：
const arr = ['1', '2', '3', '4'] // we wanna delete number "3"
第一种方式：
arr.indexOf('3') !== -1 && arr.splice(arr.indexOf('3'), 1)
第二种方式（ES6）特别无变异：
const newArr = arr.filter(e => e !== '3')
【讨论】：
最简单的解决方案是：
array - 移除某些元素的数组 valueForRemove; valueForRemove - 移除元素；
array.filter(arrayItem => !array.includes(valueForRemove));
更简单：
array.filter(arrayItem => arrayItem !== valueForRemove);
不漂亮，但有效：
array.filter(arrayItem => array.indexOf(arrayItem) != array.indexOf(valueForRemove))
不漂亮，但有效：
while(array.indexOf(valueForRemove) !== -1) {
array.splice(array.indexOf(valueForRemove), 1)
}
附： filter() 方法创建一个新数组，其中包含通过所提供函数实现的测试的所有元素。见https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
【讨论】：
newArray = array.filter... 然后：array = newArray 并且项目从 array 消失。
在所有唯一值中，您可以：
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]
【讨论】：
ES6 方式。
const commentsWithoutDeletedArray = commentsArray.filter(comment => comment.Id !== commentId);
【讨论】：
const removeArrayItem = (arr, itemToRemove) => { return arr.includes(itemToRemove)? arr.splice(arr.indexOf(itemToRemove), 1): arr }
comment.Id !== commentId 现在我要删除的commecnt 是5 现在在过滤器5 !== 5 它是假的那么如何删除它：\？
您可以使用 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>【讨论】：
在全局函数中我们不能直接传递自定义值，但是有很多方法如下
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
【讨论】：
真的，我不明白为什么不能解决这个问题
arr = arr.filter(value => value !== 'seven');
或者也许你想使用 vanilla JS
arr = arr.filter(function(value) { return value !== 'seven' });
【讨论】：
'seven'的新数组
您可以使用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>【讨论】：
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]
【讨论】：
您可以从Lodash 使用without 或pull：
const _ = require('lodash');
_.without([1, 2, 3, 2], 2); // -> [1, 3]
【讨论】：
鉴于没有漂亮的，这里有一个简单且可重用的 ES6 函数。
const removeArrayItem = (arr, itemToRemove) => {
return arr.filter(item => item !== itemToRemove)
}
用法：
const items = ['orange', 'purple', 'orange', 'brown', 'red', 'orange']
removeArrayItem(items, 'orange')
【讨论】：
一个适用于所有浏览器且没有任何框架的非常干净的解决方案是分配一个新数组并简单地返回它而不包含您要删除的项目：
/**
* @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;
}
【讨论】：
这是一个使用 jQuery 的 inArray function 的版本：
var index = $.inArray(item, array);
if (index != -1) {
array.splice(index, 1);
}
【讨论】：
这样查看：
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');
【讨论】：
removeItem(array, 'seven, eight')，但它不起作用。
单线就可以了，
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) 相比，过滤器是一种看起来更好（并且可链接）的便捷方法。
【讨论】：
&& 作为值可以添加任意数量的值。
true 时，生成的数组将保留该元素。在false 上省略。
array = array.filter()，而不仅仅是array.filter()。
filter() does not mutate the array on which it is called. from developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…）。
无损移除：
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;
}
【讨论】：
//编辑感谢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']
希望对你有帮助
【讨论】：
for in 用于数组，这是不好的做法，如果有人触摸了数组原型，你就完了。
您可以使用underscore.js。它真的让事情变得简单。
例如，用这个：
var result = _.without(['three','seven','eleven'], 'seven');
而result 将是['three','eleven']。
在您的情况下，您必须编写的代码是：
ary = _.without(ary, 'seven')
它减少了您编写的代码。
【讨论】：
诀窍是从头到尾遍历数组，因此在删除元素时不会弄乱索引。
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 现在是 ["red", "black", "white"]
【讨论】：
我使用了投票最多的选项并创建了一个函数，该函数将使用另一个不需要的单词数组来清除一个单词数组：
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)
【讨论】：
你所追求的是过滤器
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
【讨论】：
请不要使用带有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' ]
【讨论】：
另一种变化：
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 循环。
【讨论】：
//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]]
【讨论】：