如何通过值从数组中删除项目？

你可以像这样使用#0方法：

var index = array.indexOf(item);if (index !== -1) {array.splice(index, 1);}

说明：您需要为IE8及以下版本提供垫片

var array = [1,2,3,4]var item = 3
var index = array.indexOf(item);array.splice(index, 1);
console.log(array)

indexOf是一个选项，但它的实现基本上是在整个数组中搜索值，因此执行时间随着数组大小而增长。（所以我猜它在每个浏览器中，我只检查了Firefox）。

我没有IE6可以检查，但我敢打赌，你可以在几乎任何客户端机器上以这种方式每秒检查至少一百万个数组项。如果[数组大小]*[每秒搜索次数]可能超过一百万，你应该考虑不同的实现。

基本上，你可以使用一个对象为你的数组创建一个索引，如下所示：

var index={'three':0, 'seven':1, 'eleven':2};

任何健全的JavaScript环境都会为这些对象创建一个可搜索的索引，以便您可以快速将键转换为值，无论对象有多少属性。

这只是基本的方法，根据您的需要，您可以组合多个对象和/或数组，使相同的数据可以快速搜索不同的属性。如果您指定您的确切需求，我可以建议更具体的数据结构。

如果不允许添加到本机原型，这可以是全局函数或自定义对象的方法。它会从数组中删除与任何参数匹配的所有项。

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

看看这个方式：

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

var index = array.indexOf('item');
if(index!=-1){
array.splice(index, 1);}

var remove = function(array, value) {var index = null;
while ((index = array.indexOf(value)) !== -1)array.splice(index, 1);
return array;};

您可以使用underscore.js。它确实使事情变得简单。

例如，通过这个：

var result = _.without(['three','seven','eleven'], 'seven');

result将是['three','eleven']。

在您的情况下，您必须编写的代码是：

ary = _.without(ary, 'seven')

它减少了您编写的代码。

我尝试使用上面jbaron中的函数方法，但发现我需要保留原始数组以供以后使用，并创建一个像这样的新数组：

var newArray = referenceArray;

显然是通过引用而不是值创建的，因为当我从newArray中删除元素时，引用数组也将其删除了。所以我决定每次都像这样创建一个新数组：

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保持不变，而每次我执行上面的代码时，除了最新的vesselID元素之外，其他vesselArr数组都包含所有元素。

这是一个使用jQueryinArray函数的版本：

var index = $.inArray(item, array);if (index != -1) {array.splice(index, 1);}

CoffeeScript+jQuery变体：

arrayRemoveItemByValue = (arr,value) ->r=$.inArray(value, arr)unless r==-1arr.splice(r,1)# returnarr
console.log arrayRemoveItemByValue(['2','1','3'],'3')

它只删除一个，而不是全部。

一句话就行了，

var arr = ['three', 'seven', 'eleven'];
// Remove item 'seven' from arrayvar filteredArray = arr.filter(function(e) { return e !== 'seven' })//=> ["three", "eleven"]
// In ECMA6 (arrow function syntax):var filteredArray = arr.filter(e => e !== 'seven')

这使用了JS中的过滤器函数。IE9及更高版本支持它。

它的作用（来自doc链接）

filter（）为数组中的每个元素调用一次提供的回调函数，并构造一个包含回调返回强制为true的值的所有值的新数组。回调仅对已赋值的数组的索引调用；它不会为已删除或从未赋值的索引调用。未通过回调测试的数组元素会被简单地跳过，并且不包含在新数组中。

所以基本上，这与所有其他for (var key in ary) { ... }解决方案相同，除了从IE6开始支持#1构造。

基本上，filter是一种方便的方法，与for in构造（AFAIK）相比，它看起来更好（并且是可链接的）。

从数组中删除所有匹配的元素（而不仅仅是第一个，因为这里似乎是最常见的答案）：

while ($.inArray(item, array) > -1) {array.splice( $.inArray(item, array), 1 );}

我使用jQuery进行繁重的工作，但如果你想原生，你会得到这个想法。

//This function allows remove even array from arrayvar 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]]

另一个变化：

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（），但假设要删除的数组相对于要清理的数组较小；每次删除都会缩短这时候循环。

请不要将变体与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' ]

你追求的是过滤器

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

我使用了投票最多的选项并创建了一个函数，该函数将使用另一个不需要的单词数组清理一个单词数组：

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)

诀窍是从头到尾遍历数组，因此在删除元素时不会弄乱索引。

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现在是[“红色”，“黑色”，“白色”]

//编辑感谢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" lengthbreak;}}}var goodGuys=wantDelete('bush', ['obama', 'bush', 'clinton']); //['obama', 'clinton']

希望这能帮助你

在所有浏览器和没有任何框架的情况下，一个非常干净的解决方案是分配一个新的数组并简单地返回它，而不返回您要删除的项目：

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

您可以从Lodash中使用without或pull：

const _ = require('lodash');_.without([1, 2, 3, 2], 2); // -> [1, 3]

无损去除：

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

您可以使用Lodash拉函数

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>

如果您有唯一值并且排序无关紧要，请使用设置，它具有删除：

var mySet = new Set(['three', 'seven', 'eleven']);mySet.delete('seven'); // Returns true, successfully removed[...mySet];            // Returns ['three', 'eleven']

ES6方式。

const commentsWithoutDeletedArray = commentsArray.filter(comment => comment.Id !== commentId);

鉴于没有一个漂亮的，这里有一个简单且可重用的ES6函数。

const removeArrayItem = (arr, itemToRemove) => {return arr.filter(item => item !== itemToRemove)}

用法：

const items = ['orange', 'purple', 'orange', 'brown', 'red', 'orange']removeArrayItem(items, 'orange')

你可以用这两种方式做到这一点：

const arr = ['1', '2', '3', '4'] // we wanna delete number "3"

1. 第一种方法：

   arr.indexOf('3') !== -1 && arr.splice(arr.indexOf('3'), 1)

2. The second way (ES6) specially without mutate:

   const newArr = arr.filter(e => e !== '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]

您可以使用plice从数组中删除单个元素，但plice不能从数组中删除多个类似的元素。

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]

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]

在全局函数中，我们不能直接传递自定义值，但有很多方法如下

 var ary = ['three', 'seven', 'eleven'];var index = ary.indexOf(item);//item: the value which you want to remove
//Method 1ary.splice(index,1);
//Method 2delete ary[index]; //in this method the deleted element will be undefined

真的我不明白为什么这件事不能用

arr = arr.filter(value => value !== 'seven');

或者你想使用香草JS

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

您可以使用Lodash#0函数来实现这一点。

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>

方法1

var ary = ['three', 'seven', 'eleven'];var index = ary.indexOf('seven'); // get index if value found otherwise -1
if (index > -1) { //if foundary.splice(index, 1);}

方法2

单线解决方案

var ary = ['three', 'seven', 'eleven'];filteredArr = ary.filter(function(v) { return v !== 'seven' })

// Or using ECMA6:filteredArr = ary.filter(v => v !== 'seven')

在所有唯一值中，您可以：

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]

最简单的解决方案是：

数组-删除一些元素值的数组ForRemove；ValeForRemove-删除元素；

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

P. S. filter（）方法创建一个新数组，其中包含通过所提供函数实现的测试的所有元素。请参阅https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

看看这个方式：

delete this.arrayName[this.arrayName.indexOf(value)];

参考：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete

您可以创建自己的方法，传递数组和要删除的值：

function removeItem(arr, item){return arr.filter(f => f !== item)}

你可以这样称呼它：

ary = removeItem(ary, 'seven');