Array.prototype.removeByValue = function (val) {
  for (var i = 0; i < this.length; i++) {
    if (this[i] === val) {
      this.splice(i, 1);
      i--;
    }
  }
  return this;
}

var fruits = ['apple', 'banana', 'carrot', 'orange'];
fruits.removeByValue('banana');

console.log(fruits);
// -> ['apple', 'carrot', 'orange']

我不知道你期望如何表现。我能想到的三种可能性是你可能想要的。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];

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

splice（） 方法通过删除 现有元素和/或添加新元素。

const array = [2, 5, 9];

console.log(array);

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

// array = [2, 9]
console.log(array); 

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

为了完整起见，这里是函数。第一个函数仅删除单个匹配项（即删除 from 的第一个匹配项），而第二个函数删除所有匹配项：5[2,5,9,1,5,8,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;
}
// Usage
console.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()

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

如果您想要删除已删除位置的新数组，则始终可以删除特定元素并过滤掉该数组。对于未实现 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
   

使用 for 数组时要小心。它适用于删除对象的属性，但不适用于数组。最好用于数组。deletesplice

请记住，当您用于数组时，可能会得到错误的结果。换句话说，将删除该元素，但不会更新 length 属性的值。deleteanArray.lengthdelete

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

如果出于某种原因被迫使用，那么当您需要遍历数组时，您应该使用 for each loops。事实上，如果可能的话，请始终避免使用索引循环。这样一来，代码将更加健壮，并且不容易出现索引问题。deletefor

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

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

Array.prototype.destroy = function(obj){
    // Return null if no objects were found and removed
    var destroyed = null;

    for(var i = 0; i < this.length; i++){

        // Use while-loop to find adjacent equal objects
        while(this[i] === obj){

            // Remove this[i] and store it within destroyed
            destroyed = this.splice(i, 1)[0];
        }
    }

    return destroyed;
}

用法：

var x = [1, 2, 3, 3, true, false, undefined, false];

x.destroy(3);         // => 3
x.destroy(false);     // => false
x;                    // => [1, 2, true, undefined]

x.destroy(true);      // => true
x.destroy(undefined); // => undefined
x;                    // => [1, 2]

x.destroy(3);         // => null
x;                    // => [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)

您可以遍历每个 -item 和它（如果它存在于 .arraysplicearray

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（未找到时返回 index 或 -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 的原始实现没有这个问题。

无需使用 或 .但是，如果您只想删除一个元素的一次出现，则它的性能会更好。indexOfsplice

查找和移动（move）：

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 大约比 move 慢 10 倍。即使通过删除对拼接的调用来改进，它的性能也比移动差得多。indexOf

Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_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 - 1
            return;
        }
    }
}

var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];
recentMovies.removeItem('Superman');

我还遇到了不得不从 中删除元素的情况。 在Internet Explorer中不起作用，因此我正在分享我的工作解决方案：Array.indexOfjQuery.inArray()

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

编辑于2016年10月

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

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

但要注意，每次创建新数组都会对性能造成很大影响。如果列表非常大（想想 10k+ 项目），那么请考虑使用其他方法。

删除项目（ECMA-262 第 5 版代码，又名旧式 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 ]

重要Internet Explorer、Chrome 45 之前版本、Firefox 22 版本之前和 Safari 版本 10 之前完全不支持 ECMAScript 6 箭头函数语法。要在旧浏览器中使用 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 ]

重要提示 Internet Explorer 不支持该功能，Chrome 47 之前版本、Firefox 43 版本之前、Safari 版本 9 之前和 Edge 版本低于 14，但您可以使用 core-js 进行 polyfill。array.includes(...)

删除多个项目（将来可能会）

如果“This-Binding Syntax”提案被接受，您将能够执行以下操作：

// 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.prototype
arr = arr::remove(2, 3, 5)

console.log(arr)
// [ 1, 4 ]

在 BabelJS 中亲自试一试:)

参考

• Array.prototype.includes
• 功能组成

我是 JavaScript 的新手，需要这个功能。我只是写了这个：

function removeFromArray(array, item, index) {
  while((index = array.indexOf(item)) > -1) {
    array.splice(index, 1);
  }
}

然后当我想使用它时：

//Set-up some dummy data
var dummyObj = {name:"meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];

//Remove the dummy data
removeFromArray(dummyArray, dummyObj);
removeFromArray(dummyArray, "item2");

输出 - 按预期。 [“项目 1”、“项目 1”]

您可能有与我不同的需求，因此您可以轻松地对其进行修改以适应他们。我希望这对某人有所帮助。

基于所有基本正确的答案，并考虑到建议的最佳实践（特别是不直接使用 Array.prototype），我想出了以下代码：

function arrayWithout(arr, values) {
  var isArray = function(canBeArray) {
    if (Array.isArray) {
      return Array.isArray(canBeArray);
    }
    return Object.prototype.toString.call(canBeArray) === '[object Array]';
  };

  var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1);
  var arrCopy = arr.slice(0);

  for (var i = arrCopy.length - 1; i >= 0; i--) {
    if (excludedValues.indexOf(arrCopy[i]) > -1) {
      arrCopy.splice(i, 1);
    }
  }

  return arrCopy;
}

回顾上述功能，尽管它工作正常，但我意识到可以有一些性能改进。此外，使用 ES6 而不是 ES5 也是一种更好的方法。为此，这是改进的代码：

const arrayWithoutFastest = (() => {
  const isArray = canBeArray => ('isArray' in Array) 
    ? Array.isArray(canBeArray) 
    : Object.prototype.toString.call(canBeArray) === '[object Array]';

  let mapIncludes = (map, key) => map.has(key);
  let objectIncludes = (obj, key) => key in obj;
  let includes;

  function arrayWithoutFastest(arr, ...thisArgs) {
    let withoutValues = isArray(thisArgs[0]) ? thisArgs[0] : thisArgs;

    if (typeof Map !== 'undefined') {
      withoutValues = withoutValues.reduce((map, value) => map.set(value, value), new Map());
      includes = mapIncludes;
    } else {
      withoutValues = withoutValues.reduce((map, value) => { map[value] = value; return map; } , {}); 
      includes = objectIncludes;
    }

    const arrCopy = [];
    const length = arr.length;

    for (let i = 0; i < length; i++) {
      // If value is not in exclude list
      if (!includes(withoutValues, arr[i])) {
        arrCopy.push(arr[i]);
      }
    }

    return arrCopy;
  }

  return arrayWithoutFastest;  
})();

如何使用：

const arr = [1,2,3,4,5,"name", false];

arrayWithoutFastest(arr, 1); // will return array [2,3,4,5,"name", false]
arrayWithoutFastest(arr, 'name'); // will return [2,3,4,5, false]
arrayWithoutFastest(arr, false); // will return [2,3,4,5]
arrayWithoutFastest(arr,[1,2]); // will return [3,4,5,"name", false];
arrayWithoutFastest(arr, {bar: "foo"}); // will return the same array (new copy)

我目前正在写一篇博文，其中我对 Array 的几种解决方案进行了基准测试，并比较了运行所需的时间。一旦我完成那篇帖子，我将使用链接更新此答案。只是为了让您知道，我已经将上述内容与 lodash 的 without 进行了比较，如果浏览器支持 ，它击败了 lodash！请注意，我没有使用 或 将 exlcudeValues 包装在 or 中，使查询速度更快！MapArray.prototype.indexOfArray.prototype.includesMapObject

在 CoffeeScript 中：

my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value

我知道已经有很多答案，但其中许多似乎使问题过于复杂。下面是一种简单的递归方法，用于删除键的所有实例 - 调用 self，直到找不到索引。是的，它仅适用于 的浏览器，但它很简单，可以很容易地填充。indexOf

独立功能

function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

    array.splice(index, 1);
    removeAll(array,key);
}

原型方法

Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}

您可以使用过滤器方法轻松完成：

function remove(arrOriginal, elementToRemove){
    return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log(remove([1, 2, 1, 0, 3, 1, 4], 1));

这会从数组中删除所有元素，并且工作速度也比 和 的组合更快。sliceindexOf

我喜欢这个版本的拼接，使用以下命令按其值删除元素：$.inArray

$(document).ready(function(){
    var arr = ["C#","Ruby","PHP","C","C++"];
    var itemtoRemove = "PHP";
    arr.splice($.inArray(itemtoRemove, arr),1);
});

这提供了一个谓词，而不是一个值。

注意：它将更新给定的数组，并返回受影响的行。

用法

var removed = helper.remove(arr, row => row.id === 5 );

var removed = helper.removeAll(arr, row => row.name.startsWith('BMW'));

定义

var helper = {
 // Remove and return the first occurrence

 remove: function(array, predicate) {
  for (var i = 0; i < array.length; i++) {
   if (predicate(array[i])) {
    return array.splice(i, 1);
   }
  }
 },

 // Remove and return all occurrences

 removeAll: function(array, predicate) {
  var removed = [];

  for (var i = 0; i < array.length; ) {
   if (predicate(array[i])) {
    removed.push(array.splice(i, 1));
    continue;
   }
   i++;
  }
  return removed;
 },
};

下划线.js可用于解决多个浏览器的问题。它使用内置浏览器方法（如果存在）。如果它们不存在，就像在较旧的 Internet Explorer 版本中一样，它会使用自己的自定义方法。

从数组中删除元素的简单示例（从网站）：

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]

var index,
    input = [1,2,3],
    indexToRemove = 1;
    integers = [];

for (index in input) {
    if (input.hasOwnProperty(index)) {
        if (index !== indexToRemove) {
            integers.push(result); 
        }
    }
}
input = integers;

此解决方案将采用一个输入数组，并在输入中搜索要删除的值。这将遍历整个输入数组，结果将是删除了特定索引的第二个数组整数。然后将整数数组复制回输入数组中。

使用 jQuery 的 InArray：

A = [1, 2, 3, 4, 5, 6];
A.splice($.inArray(3, A), 1);
//It will return A=[1, 2, 4, 5, 6]`   

注意：如果未找到该元素，inArray 将返回 -1。

删除带有索引和拼接的值！

function removeArrValue(arr,value) {
    var index = arr.indexOf(value);
    if (index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}

如果您必须支持旧版本的 Internet Explorer，我建议使用以下 polyfill（注意：这不是一个框架）。它是所有现代数组方法（JavaScript 1.8.5 / ECMAScript 5 Array Extras）的 100% 向后兼容替代品，适用于 Internet Explorer 6+、Firefox 1.5+、Chrome、Safari 和 Opera。

https://github.com/plusdude/array-generics

这里有很多奇妙的答案，但对我来说，最有效的方法不是从数组中完全删除我的元素，而是简单地将其值设置为 null。

这适用于我所拥有的大多数情况，并且是一个很好的解决方案，因为我稍后将使用该变量并且不希望它消失，只是现在为空。此外，这种方法是完全跨浏览器兼容的。

array.key = null;

如果数组中有复杂的对象，您可以使用过滤器吗？ 在或不那么容易使用的情况下。特别是当对象在数组中可能很浅时。$.inArrayarray.splice

例如，如果您有一个带有 id 字段的对象，并且您希望从数组中删除该对象：

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});

你可以使用 lodash _.pull（突变数组）、_.pullAt（突变数组）或 _.withun（不变异数组），

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

以下方法将从数组中删除给定值的所有条目，而无需创建新数组，并且只需一次超快的迭代。它适用于古老的 Internet Explorer 5.5 浏览器：

function removeFromArray(arr, removeValue) {
  for (var i = 0, k = 0, len = arr.length >>> 0; i < len; i++) {
    if (k > 0)
      arr[i - k] = arr[i];

    if (arr[i] === removeValue)
      k++;
  }

  for (; k--;)
    arr.pop();
}

var a = [0, 1, 0, 2, 0, 3];

document.getElementById('code').innerHTML =
  'Initial array [' + a.join(', ') + ']';
//Initial array [0, 1, 0, 2, 0, 3]

removeFromArray(a, 0);

document.getElementById('code').innerHTML +=
  '<br>Resulting array [' + a.join(', ') + ']';
//Resulting array [1, 2, 3]

<code id="code"></code>

删除上次出现或所有出现，还是第一次出现？

var array = [2, 5, 9, 5];

// Remove last occurrence (or all occurrences)
for (var i = array.length; i--;) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Remove this line to remove all occurrences
  }
}

或

var array = [2, 5, 9, 5];

// Remove first occurrence
for (var i = 0; array.length; i++) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Do not remove this line
  }
}

通过我的解决方案，由于纯 JavaScript，您可以删除数组中的一个或多个项目。不需要其他 JavaScript 库。

var myArray = [1,2,3,4,5]; // First array

var removeItem = function(array,value) {  // My clear function
    if(Array.isArray(value)) {  // For multi remove
        for(var i = array.length - 1; i >= 0; i--) {
            for(var j = value.length - 1; j >= 0; j--) {
                if(array[i] === value[j]) {
                    array.splice(i, 1);
                };
            }
        }
    }
    else { // For single remove
        for(var i = array.length - 1; i >= 0; i--) {
            if(array[i] === value) {
                array.splice(i, 1);
            }
        }
    }
}

removeItem(myArray,[1,4]); // myArray will be [2,3,5]

Vanilla JavaScript （ES5.1） – 就地版

浏览器支持：Internet Explorer 9 或更高版本（详细的浏览器支持）

/**
 * Removes all occurences of the item from the array.
 *
 * Modifies the array “in place”, i.e. the array passed as an argument
 * is modified as opposed to creating a new array. Also returns the modified
 * array for your convenience.
 */
function removeInPlace(array, item) {
    var foundIndex, fromIndex;

    // Look for the item (the item can have multiple indices)
    fromIndex = array.length - 1;
    foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item (in place)
        array.splice(foundIndex, 1);

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex);
    }

    // Return the modified array
    return array;
}

Vanilla JavaScript （ES5.1） – 不可变版本

浏览器支持：与原版 JavaScript 就地版相同

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    var arrayCopy;

    arrayCopy = array.slice();

    return removeInPlace(arrayCopy, item);
}

Vanilla ES6 – 不可变版本

浏览器支持：Chrome 46、Edge 12、Firefox 16、Opera 37、Safari 8（详细的浏览器支持）

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    // Copy the array
    array = [...array];

    // Look for the item (the item can have multiple indices)
    let fromIndex = array.length - 1;
    let foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item by generating a new array without it
        array = [
            ...array.slice(0, foundIndex),
            ...array.slice(foundIndex + 1),
        ];

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex)
    }

    // Return the new array
    return array;
}

一种更现代的 ECMAScript 2015（以前称为 Harmony 或 ES 6）方法。鉴于：

const items = [1, 2, 3, 4];
const index = 2;

然后：

items.filter((x, i) => i !== index);

屈服：

[1, 2, 4]

你可以使用 Babel 和 polyfill 服务来确保跨浏览器都得到很好的支持。

我认为许多 JavaScript 指令对于函数式编程来说没有经过深思熟虑。Splice 返回已删除的元素，其中大部分时间需要缩减数组。这很糟糕。

想象一下，您正在执行递归调用，并且必须传递一个少了一个项的数组，可能没有当前的索引项。或者想象一下，您正在执行另一个递归调用，并且必须传递一个推送元素的数组。

在这两种情况下，您都不能执行 或 .第一个白痴实际上会传递数组的长度，第二个白痴会将已删除的元素作为参数传递。myRecursiveFunction(myArr.push(c))myRecursiveFunction(myArr.splice(i,1))

所以我实际上所做的......为了删除数组元素并同时将结果作为参数传递给函数，我执行以下操作

myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))

说到推动，那就更傻了......我确实喜欢，

myRecursiveFunction((myArr.push(c),myArr))

我相信在适当的函数式语言中，改变它被调用的对象的方法必须返回对对象的引用。

Array.prototype.remove = function(x) {
    var y=this.slice(x+1);
    var z=[];
    for(i=0;i<=x-1;i++) {
        z[z.length] = this[i];
    }

    for(i=0;i<y.length;i++){
        z[z.length]=y[i];
    }

    return z;
}

使用 jQuery.grep（）：

var y = [1, 2, 3, 9, 4]
var removeItem = 9;

y = jQuery.grep(y, function(value) {
  return value != removeItem;
});
console.log(y)

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>

我对基本 JavaScript 数组做了一个相当有效的扩展：

Array.prototype.drop = function(k) {
  var valueIndex = this.indexOf(k);
  while(valueIndex > -1) {
    this.removeAt(valueIndex);
    valueIndex = this.indexOf(k);
  }
};

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

ES6 &无突变：（2016 年 10 月）

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)

虽然前面的大多数答案都回答了这个问题，但为什么没有使用这种方法还不够清楚。是的，符合不可变性标准，但是执行以下较短的等效项怎么样？slice()filter()

const myArray = [1,2,3,4];

现在假设我们应该从数组中删除第二个元素，我们可以简单地做：

const newArray = myArray.slice(0, 1).concat(myArray.slice(2, 4));

// [1,3,4]

这种从数组中删除元素的方式，由于其简单且不可变的性质，今天在社区中受到强烈鼓励。一般情况下，应避免使用引起突变的方法。例如，建议您将 替换为 和 。push()concat()splice()slice()

我做了一个函数：

function pop(valuetoremove, myarray) {
    var indexofmyvalue = myarray.indexOf(valuetoremove);
    myarray.splice(indexofmyvalue, 1);
}

并像这样使用它：

pop(valuetoremove, myarray);

使用松散比较删除一个值，而不改变原始数组 ES6

/**
 * Removes one instance of `value` from `array`, without mutating the original array. Uses loose comparison.
 *
 * @param {Array} array Array to remove value from
 * @param {*} value Value to remove
 * @returns {Array} Array with `value` removed
 */
export function arrayRemove(array, value) {
    for(let i=0; i<array.length; ++i) {
        if(array[i] == value) {
            let copy = [...array];
            copy.splice(i, 1);
            return copy;
        }
    }
    return array;
}

删除索引 i 处的元素，而不改变原始数组：

/**
* removeElement
* @param {Array} array
* @param {Number} index
*/
function removeElement(array, index) {
   return Array.from(array).splice(index, 1);
}

// Another way is
function removeElement(array, index) {
   return array.slice(0).splice(index, 1);
}

2017-05-08

大多数给定的答案都适用于严格的比较，这意味着两个对象在内存中引用完全相同的对象（或者是基元类型），但通常您希望从具有特定值的数组中删除非基元对象。例如，如果您调用服务器并希望根据本地对象检查检索到的对象。

const a = {'field': 2} // Non-primitive object
const b = {'field': 2} // Non-primitive object with same value
const c = a            // Non-primitive object that reference the same object as "a"

assert(a !== b) // Don't reference the same item, but have same value
assert(a === c) // Do reference the same item, and have same value (naturally)

//Note: there are many alternative implementations for valuesAreEqual
function valuesAreEqual (x, y) {
   return  JSON.stringify(x) === JSON.stringify(y)
}


//filter will delete false values
//Thus, we want to return "false" if the item
// we want to delete is equal to the item in the array
function removeFromArray(arr, toDelete){
    return arr.filter(target => {return !valuesAreEqual(toDelete, target)})
}

const exampleArray = [a, b, b, c, a, {'field': 2}, {'field': 90}];
const resultArray = removeFromArray(exampleArray, a);

//resultArray = [{'field':90}]

valuesAreEqual 有替代/更快的实现，但这可以完成工作。如果您有要检查的特定字段（例如，某些检索到的 UUID 与本地 UUID），也可以使用自定义比较器。

另请注意，这是一个函数式操作，这意味着它不会改变原始数组。

好的，例如，你有下面的数组：

var num = [1, 2, 3, 4, 5];

我们想删除数字 4。您可以简单地使用以下代码：

num.splice(num.indexOf(4), 1); // num will be [1, 2, 3, 5];

如果要重用此函数，请编写一个可重用的函数，该函数将附加到本机数组函数，如下所示：

Array.prototype.remove = Array.prototype.remove || function(x) {
  const i = this.indexOf(x);
  if(i===-1)
      return;
  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) // Return [1, 2, 3, 4, 6]

此外，还有一些第三方库可以帮助您做到这一点，例如 Lodash 或 Underscore。有关更多信息，请查看 lodash _.pull、_.pullAt 或 _.without。

按索引删除

返回数组副本的函数，索引处没有元素：

/**
* removeByIndex
* @param {Array} array
* @param {Number} index
*/
function removeByIndex(array, index){
      return array.filter(function(elem, _index){
          return index != _index;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByIndex(l, 1));

$> [ 1, 4, 5, 6, 7 ]

按值删除

返回不带 Value 的数组副本的函数。

/**
* removeByValue
* @param {Array} array
* @param {Number} value
*/
function removeByValue(array, value){
      return array.filter(function(elem, _index){
          return value != elem;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByValue(l, 5));

$> [ 1, 3, 4, 6, 7]

已经有很多答案了，但是因为还没有人用一个衬垫来做到这一点，我想我会展示我的方法。它利用了这样一个事实，即 string.split（） 函数将在创建数组时删除所有指定的字符。下面是一个示例：

var ary = [1,2,3,4,1234,10,4,5,7,3];
out = ary.join("-").split("-4-").join("-").split("-");
console.log(out);

在此示例中，所有 4 都将从数组 ary 中删除。但是，需要注意的是，任何包含字符“-”的数组都会导致此示例出现问题。简而言之，它会导致 join（“-”） 函数错误地将字符串拼凑在一起。在这种情况下，上述 snipet 中的所有“-”字符串都可以替换为原始数组中不会使用的任何字符串。这是另一个示例：

var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
out = ary.join("!@#").split("!@#4!@#").join("!@#").split("!@#");
console.log(out);

我发布了我的代码，删除了一个数组元素，并减少了数组长度。

function removeElement(idx, arr) {
    // Check the index value
    if (idx < 0 || idx >= arr.length) {
        return;
    }
    // Shift the elements
    for (var i = idx; i > 0; --i) {
        arr[i] = arr[i - 1];
    }
    // Remove the first element in array
    arr.shift();
}

对于任何希望复制将返回删除了重复数字或字符串的新数组的方法的人来说，这已经从现有答案中整理出来：

function uniq(array) {
  var len = array.length;
  var dupFree = [];
  var tempObj = {};

  for (var i = 0; i < len; i++) {
    tempObj[array[i]] = 0;
  }

  console.log(tempObj);

  for (var i in tempObj) {
    var element = i;
    if (i.match(/\d/)) {
      element = Number(i);
    }
    dupFree.push(element);
  }

  return dupFree;
}

真是太可惜你有一个整数数组，而不是一个键是这些整数的字符串等效项的对象。

我看过很多这样的答案，据我所知，它们似乎都使用了“蛮力”。我没有检查每一个，如果不是这样，请道歉。对于一个小数组，这很好，但是如果你里面有 000 个整数怎么办？

如果我错了，请纠正我，但是我们不能假设在JavaScript对象的那种映射中，可以假设密钥检索机制是高度工程化和优化的吗？（注意：如果某个超级专家告诉我情况并非如此，我可以建议改用 ECMAScript 6 的 Map 类，这肯定会）。key => value

我只是建议，在某些情况下，最好的解决方案可能是将数组转换为对象......当然，问题是您可能有重复的整数值。我建议将它们作为条目的“价值”部分放在桶中。（注意：如果你确定你没有任何重复的数组元素，这可能要简单得多：值“与”键相同，然后去取回你修改后的数组）。key => valueObject.values(...)

因此，您可以执行以下操作：

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 bucket
    acc[ val ].push( currIndex );
    return acc;
}
const myIntsMapObj = arr.reduce( f, {});

console.log( myIntsMapObj );

输出：

对象 [ <1 空插槽>， 数组 1， 数组 [2]， 阵列 1， 阵列1， <5 Empty slots>， 46 更多... ]

然后很容易删除所有数字 55。

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

您不必全部删除它们：索引值会按出现顺序推送到其存储桶中，因此（例如）：

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

将分别删除第一个和最后一个匹配项。您可以轻松计算发生频率，通过将一个桶的内容转移到另一个桶中，将所有 55 秒替换为 3 秒等。

从“存储桶对象”中检索修改后的数组略有复杂，但并不复杂：每个存储桶都包含由 （） 键表示的值的索引（在原始数组中）。这些存储桶值中的每一个也是唯一的（每个值都是原始数组中的唯一索引值）：因此，您可以将它们转换为新对象中的键，并将“整数字符串键”中的（实际）整数作为值......然后对键进行排序并转到 .intstringObject.values( ... )

这听起来非常复杂和耗时......但显然，一切都取决于情况和所需的用途。我的理解是，JavaScript 的所有版本和上下文都只在一个线程中运行，并且线程不会“放手”，因此“蛮力”方法可能会出现一些可怕的拥塞：与其说是由操作引起的，不如说是由多个重复/操作引起的。indexOfslicesplice

补遗如果您确定这对您的用例来说工程量太大，那么最简单的“蛮力”方法肯定是

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

我刚刚在 via 上创建了一个 polyfill 来删除数组中所需的元素，而不会在以后通过Array.prototypeObject.definePropertyfor .. 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-prototype
  Object.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.removekey => valueObject

删除对象值

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

您的问题没有说明是否需要顺序或非重复值。

如果您不关心顺序，并且不会多次在容器中具有相同的值，请使用 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 = 3
const 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 的原型设计功能在数组对象上定义一个名为 remove（） 的方法。

使用 splice（） 方法来满足您的要求。

请看下面的代码。

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 array
    var index = this.indexOf(item);

    if (index > -1) {
        // The splice() method is used to add/remove items(s) in the array
        this.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.js REPL 上执行的完整示例代码，其中描述了 push（）、pop（）、shift（）、unshift（） 和 splice（） 方法的使用。

> // Defining an array
undefined
> var arr = [12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34];
undefined
> // Getting length of array
undefined
> arr.length;
16
> // Adding 1 more item at the end i.e. pushing an item
undefined
> 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 beginning
undefined
> arr.shift()
12
> arr
[ 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Add item(s) at beginning
undefined
> arr.unshift(67); // Add 67 at beginning of the array and return number of items in updated/new array
16
> 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 array
18
> 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 -1
undefined
> 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 22
1
> arr
[ 11, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.remove(67)    // Remove 67
1
> arr
[ 11, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(89)    // Remove 89
2
> 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();

从第一个删除元素

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

如果指定 only，则仅删除一个元素。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)
}

有用的是，您可以在咖喱表达式中使用它，例如：

[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：要从中删除特定内容的数组

stringToRemoveFromArray：要删除的字符串，1 是要删除的元素数。

注意：如果“stringToRemoveFromArray”不在数组中，这将删除数组的最后一个元素。

在删除元素之前，最好先检查数组中是否存在该元素。

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（） 方法效果很好。

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

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

here 是必需的，rest 参数是可选的。index

例如：

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]
   

   或者使用 splice（） 方法：

   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]
   

   或者假设我们想从数组中删除：delarr

   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. 如果您只知道元素的位置（或索引），但不知道元素的位置（或索引），并且只想使用 splice（） 方法删除第一个匹配的元素：

   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]
   

reduce方法的止盈如下：

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

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

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

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

splice（） 方法

array.splice(index, 1);    

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

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

delete 方法

delete array[index]

filter（） 方法

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

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

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

通常，最好只使用该函数创建一个新数组。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 found
numbers.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 = 0
    for (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>

我想建议使用 delete 和 filter 删除一个数组项：

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 和 splice
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 array
colors.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）上对选定的解决方案进行了性能测试。我显示了 （A），但与其他方法相比，我没有使用它，因为它在数组中留下了空白空间。delete

结论

• 最快的解决方案是 （C）（除了 Safari 用于小阵列，它有第二次）array.splice
• 对于大数组，（H） 是 Firefox 和 Safari 最快的不可变解决方案; （B） 在 Chrome 中速度最快array.slice+spliceArray.from
• 可变解决方案通常比不可变解决方案快 1.5-6 倍
• 对于Safari上的小桌子，令人惊讶的是，可变解决方案（C）比不可变解决方案（G）慢

详

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

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

在 Chrome 中，（C） 是最快的就地解决方案。（D） 是最快的不可变解。最慢的是 （F）。您可以在此处在计算机上执行测试。array.splicearray.filterarray.slice

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

在Chrome中，（C）是最快的就地解决方案（（C）的速度也差不多，但它在数组中留下了一个空插槽（因此它不会执行“完全删除”））。（H） 是最快的不可变解。最慢的是（D 和 E）。您可以在此处在计算机上执行测试。array.splicedeletearray.slice-splicearray.filter

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.

浏览器比较：Chrome v78.0.0、Safari v13.0.4 和 Firefox v71.0.0

使用过滤器选项可以在一行中从数组中删除特定元素，并且所有浏览器都支持它： 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

让我们考虑一个长度为 的数组，其值为 10,20,30,40,50，我想从中删除值 30。5

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

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

因此，再次分配很重要。

这导致了另一个问题。你不能让变量 .它应该是 或 .constletvar

ES10 [美]

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

1. 一般情况

1.1. 使用.splice()

|就地：是 |
|删除重复项：Yes（loop）、No（indexOf） |
|按值/指数： 按指数 |

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

// With a 'for' loop
const 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() method
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. 使用 方法删除 Array 元素.filter()

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

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

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

1.3. 通过扩展删除 Array 元素Array.prototype

|就地：是/否（取决于实施）|
|删除重复项：是/否（取决于实现） |
|按值/指数：按指数/按值（取决于实现） |

Array 的原型可以使用其他方法进行扩展。然后，这些方法将可用于创建的数组。

注意：从标准的 JavaScript 库（如 Array）扩展对象的原型被一些人认为是一种反模式。

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

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

使用 delete 运算符不会影响 length 属性。它也不会影响后续元素的索引。数组变得稀疏，这是一种奇特的说法，即已删除的项目没有被删除，而是变得未定义。

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

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

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

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

引入了 ES10 ，它可用于从任何类似 Array 的对象创建所需的 Array，并在此过程中过滤不需要的元素。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. 更改数组长度

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

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

const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Set length to remove element
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(); // returns 6
console.log( arr ); // [1, 2, 3, 4, 5]

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

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

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

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

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

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

最快的方法是将数组变量设置为空数组。

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

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

一种使用 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（） 和 .splice（） - 可变模式

这里有两种情况：

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'); // 1
   const 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 集合提供了一种 delete 方法，用于从数组中删除特定值，然后通过扩展运算符将 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"]

splice（） 函数能够返回数组中的项目，以及从特定索引中删除项目：

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 - 从特定数组索引中删除
• filter - 允许您以编程方式从数组中删除元素

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

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

考虑

代码质量

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

为什么不是array.prototype.map？

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

支持

截至今天（2022 年 4 月 11 日），94,08% 的互联网用户的浏览器支持 array.prototype.filter。所以一般来说，使用起来是安全的。但是，IE6 - 8 不支持它。因此，如果您的用例需要支持这些浏览器，那么 Chris Ferdinanti 制作了一个很好的 polyfill。

性能

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

不同可能性的基准：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 5
var 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];
const idx = arr.indexOf(num);
arr.splice(idx, idx !== -1 ? 1 : 0);
console.log(arr); // [1, 2, 3, 3, 4]

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

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

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

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

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

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

与使用“splice（）”方法的实现类似，但它不是改变现有数组，而是创建一个新的元素数组，删除了不需要的元素。

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 库中使用“remove（）”方法

在下面的代码段中，JavaScript 库中有名为“Lodash”的 remove（） 方法。此方法也类似于过滤器方法。

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/[email protected]/lodash.min.js"></script>

5.制作自定义删除方法

JavaScript 中没有原生的“array.remove”方法，但我们可以使用上述方法创建一个，如以下代码片段所示。

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）
• 就地拆卸。
• 快速：不进行冗余迭代或重复。
• 支持删除诸如 或nullundefined

作为原型

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

（是的，我阅读了所有其他答案，但找不到一个组合在同一行中的答案。includessplice

我测试了拼接和过滤器，看看哪个更快：

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

在我的机器上，速度更快。这是有道理的，因为只是编辑一个现有数组，而创建一个新数组。splicesplicefilter

也就是说，在逻辑上更简洁（更易于阅读），并且更适合使用不可变状态的编码风格。因此，是否要做出这种权衡取决于您。filter

编辑：

要清楚一点，并做不同的事情：编辑一个数组，而创建一个新数组。但两者都可用于获取删除了给定元素的数组。splicefiltersplicefilter

使用该方法尝试此代码，您可以从数组中删除任何特定项目。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]

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

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

Array.prototype.removeByIndex = function(i) {
    if(!Number.isInteger(i) || i < 0) {
        // i must be an integer
        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.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

但是，当我们只想删除搜索值的第一次出现时，我们可以在函数中使用 Array.indexOf 方法。

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 polyfill
    const nums = [10, 20, 30];
    nums.remove(20);
    console.log(nums);//[10,30]

您可以改用 a 并使用以下函数：Setdelete

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

1. 获取数组和索引
2. 从包含数组元素的数组列表
3. 使用 method 删除特定的索引元素remove()
4. 从数组的新数组列表中列出 using 和 方法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（item） 来获取它（在 if（） 中获取一个项目，或者在 while（） 中获取所有项目）。 返回索引或 -1（如果未找到）。array.indexOf(item)

洛达什：

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

有关详细信息，请检查以下内容：.remove（array， [predicate=.identity]）

定义：

function RemoveEmptyItems(arr) {
  var result = [];
  for (var i = 0; i < arr.length; i++) if (arr[i] != null && arr[i].length > 0) result.push(arr[i]);
  return result;
}

用法：

var arr = [1,2,3, "", null, 444];
arr = RemoveEmptyItems(arr);
console.log(arr);

最干净的：

var arr = ['1','2','3'];
arr = arr.filter(e => e !== '3');
console.warn(arr);

这也将删除重复项（如果有）。

尝试使用 delete 运算符删除数组元素

例如：

const arr = [10, 20, 30, 40, 50, 60];
delete arr[2]; // It will Delete element present at index 2
console.log( arr ); // [10, 20, undefined , 40, 50, 60]

注意：使用 delete 运算符将在数组中留下空格/空洞。它不会提醒数组的长度。若要在从数组中删除元素时更改数组的长度，请改用 splice 方法。

希望这可以解决您的所有问题。

从数组中删除项的最佳方法是使用 filter 方法。 返回一个不带筛选项的新数组。.filter()

items = items.filter(e => e.id !== item.id);

此方法映射到一个完整的数组，当我返回 true 条件时，它会将当前项推送到过滤后的数组。 在此处阅读有关过滤器的更多信息。.filter()

除了所有这些解决方案之外，还可以使用 array.reduce...

const removeItem = 
    idx => 
    arr => 
    arr.reduce((acc, a, i) =>  idx === i ? acc : acc.concat(a), [])

const array = [1, 2, 3]
const index = 1

const newArray = removeItem(index)(array) 

console.log(newArray) // logs the following array to the console : [1, 3]

...或者递归函数（老实说，这不是那么优雅......也许有人有更好的递归解决方案？？...

const removeItemPrep = 
    acc => 
    i => 
    idx => 
    arr => 

    // If the index equals i, just feed in the unchanged accumulator(acc) else...
    i === idx ? removeItemPrep(acc)(i + 1)(idx)(arr) :

    // If the array length + 1 of the accumulator is smaller than the array length of the original array concatenate the array element at index i else... 
    acc.length + 1 < arr.length ? removeItemPrep(acc.concat(arr[i]))(i + 1)(idx)(arr) : 

    // return the accumulator
    acc 

const removeItem = removeItemPrep([])(0)

const array = [1, 2, 3]
const index = 1

const newArray = removeItem(index)(array) 

console.log(newArray) // logs the following array to the console : [1, 3]

了解这一点：

您可以使用 JavaScript 数组对值进行分组并遍历它们。可以通过多种方式添加和删除数组项。总共有 9 种方法（使用适合您的任何一种）。 JavaScript 数组不是 delete 方法，而是有多种方法可以清理数组值。

不同的技术方法：

您可以使用它通过以下方式从 JavaScript 数组中删除元素：

1-流行：从数组的末尾删除。

2班制：从 Array 的开头删除。

3-splice：从特定的数组索引中删除。

4- filter：这允许您以编程方式从 Array 中删除元素。

方法1：从 JavaScript 数组的开头删除元素

var ar = ['zero', 'one', 'two', 'three'];
    
ar.shift(); // returns "zero"
    
console.log( ar ); // ["one", "two", "three"]

方法2：从 JavaScript 数组的末尾删除元素

var ar = [1, 2, 3, 4, 5, 6];
    
ar.length = 4; // set length to remove elements
console.log( ar ); // [1, 2, 3, 4]


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

方法3：在 JavaScript 中使用拼接删除数组元素

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

var removed = arr.splice(2,2);
console.log(arr);


var list = ["bar", "baz", "foo", "qux"];
    
list.splice(0, 2); 
console.log(list);

方法4：使用拼接按值删除数组项

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    for( var i = 0; i < arr.length; i++){ 
    
        if ( arr[i] === 5) { 
    
            arr.splice(i, 1); 
        }
    
    }
    
    //=> [1, 2, 3, 4, 6, 7, 8, 9, 10]
    
    
var arr = [1, 2, 3, 4, 5, 5, 6, 7, 8, 5, 9, 10];
    
    for( var i = 0; i < arr.length; i++){ 
                                   
        if ( arr[i] === 5) { 
            arr.splice(i, 1); 
            i--; 
        }
    }

    //=> [1, 2, 3, 4, 6, 7, 8, 9, 10]

方法5：使用数组筛选器方法按值删除项目

  var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    var filtered = array.filter(function(value, index, arr){ 
        return value > 5;
    });
    //filtered => [6, 7, 8, 9]
    //array => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

方法6：Lodash 数组删除方法

var array = [1, 2, 3, 4];
var evens = _.remove(array, function(n) { 
                  return n % 2 === 0;
            });
            
console.log(array);// => [1, 3]console.log(evens);// => [2, 4]

方法7：制作 Remove 方法

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

function arrayRemove(arr, value) { 
    
        return arr.filter(function(ele){ 
            return ele != value; 
        });
    }
    
var result = arrayRemove(array, 6); // result = [1, 2, 3, 4, 5, 7, 8, 9, 10]

方法8：使用 Delete 运算符显式删除数组元素

var ar = [1, 2, 3, 4, 5, 6];
    
delete ar[4]; // delete element with index 4
    
console.log( ar ); // [1, 2, 3, 4, undefined, 6]
    
alert( ar ); // 1,2,3,4,,6

方法9：清除或重置 JavaScript 数组

var ar = [1, 2, 3, 4, 5, 6];
//do stuffar = [];
//a new, empty array!

var arr1 = [1, 2, 3, 4, 5, 6];
var arr2 = arr1; 
    // Reference arr1 by another variable arr1 = [];
    
console.log(arr2); 
// Output [1, 2, 3, 4, 5, 6]

var arr1 = [1, 2, 3, 4, 5, 6];
var arr2 = arr1; 
    // Reference arr1 by another variable arr1 = [];
    
console.log(arr2); 
// Output [1, 2, 3, 4, 5, 6]

总结：

通过删除 JavaScript 数组项来管理数据至关重要。虽然没有单一的“删除”功能，但您可以使用各种方法和策略清除不需要的数组元素。

function array_remove(arr, index) {
    for (let i = index; i < arr.length - 1; i++) {
        arr[i] = arr[i + 1];
    }
    arr.length -= 1;
    return arr;
}
my_arr = ['A', 'B', 'C', 'D'];
console.log(array_remove(my_arr, 0));

使用不同类型的数组进行筛选

    **simple array**
    const arr = ['1','2','3'];
    const updatedArr = arr.filter(e => e !== '3');
    console.warn(updatedArr);

    **array of object**
    const newArr = [{id:1,name:'a'},{id:2,name:'b'},{id:3,name:'c'}]
    const updatedNewArr = newArr.filter(e => e.id !== 3);
    console.warn(updatedNewArr);

    **array of object with different parameter name**
    const newArr = [{SINGLE_MDMC:{id:1,cout:10}},{BULK_MDMC:{id:1,cout:15}},{WPS_MDMC:{id:2,cout:10}},]
    const newArray = newArr.filter((item) => !Object.keys(item).includes('SINGLE_MDMC'));
    console.log(newArray)

1. 使用 indexOf，可以从数组中找到数字的特定索引
   • 使用 Splice，可以从数组中删除特定索引。

const array = [1,2,3,4,5,6,7,8,9,0];
const index = array.indexOf(5);
// find Index of specific number
if(index != -1){
    array.splice(index, 1); // remove number using index
}
console.log(array);

2. 删除所有匹配项。

let array = [1, 2, 3, 4, 5, 1, 7, 8, 9, 2, 3, 4, 5, 6];
array = array.filter(number=> number !== 5);
console.log(array);

3. 使用联接和拆分

   let array = [1, 2, 3, 4, 5, 1, 7, 8, 9, 2, 3, 4, 5, 6]
   array = Array.from(array.join("-").split("-5-").join("-").split("-"),Number)
   console.log(array)

有多种方法可以做到这一点，这取决于你希望它如何行动。

一种方法是使用该方法并从数组中删除该项：splice

let array = [1, 2, 3]
array.splice(1, 1);
console.log(array)

// return [1, 3]

但请确保传递第二个参数，否则最终会删除索引之后的整个数组。

第二种方法是使用该方法，它的好处是它是不可变的，这意味着您的主数组不会纵：filter

const array = [1, 2, 3];
const newArray = array.filter(item => item !== 2)
console.log(newArray)

// return [1, 3]

对于仅从年龄中删除第一个，而不是所有年龄：3434

ages.splice(ages.indexOf(34), 1);

或者，您可以全局定义一个方法：

function remove(array, item){
    let ind = array.indexOf(item);
    if(ind !== -1)
        array.splice(ind, 1);
}

为了消除所有年龄：34

ages = ages.filter(a => a !== 34);

如果您想删除多个项目，我发现这是最简单的：

const oldArray = [1, 2, 3, 4, 5]
const removeItems = [1, 3, 5]

const newArray = oldArray.filter((value) => {
    return !removeItems.includes(value)
})

console.log(newArray)

输出：

[2, 4]

这是我使用 splice 方法删除数组中特定数据的简单代码。拼接方法将被赋予两个参数。第一个参数是起始编号，第二个参数是 deleteCount。第二个参数用于从第一个参数的值中删除一些元素。

let arr = [1, 3, 5, 6, 9];

arr.splice(0, 2);

console.log(arr);

要通过传递项目的值来删除项目 -

const remove=(value)=>{
    myArray = myArray.filter(element=>element !=value);

}

要通过传递索引号来删除项目 -

  const removeFrom=(index)=>{
    myArray = myArray.filter((_, i)=>{
        return i!==index
    })
}

const newArray = oldArray.filter(item => item !== removeItem);

您可以在 JavaScript 中以多种方式执行此任务

1. 如果您知道值的索引：in 这种情况下，你可以使用拼接

   var arr = [1,2,3,4]
   // Let's say we have the index, coming from some API
   let index = 2;
   // splice is a destructive method and modifies the original array
   arr.splice(2, 1)
   

2. 如果您没有索引，只有值： 在这种情况下，您可以使用过滤器

   // Let's remove '2', for example
   arr = arr.filter((value)=>{
       return value !== 2;
   })
   

例如，您有一个字符数组，并希望从数组中删除“A”。

数组有一个 filter 方法，它可以过滤和只返回你想要的那些元素。

let CharacterArray = ['N', 'B', 'A'];

我想返回除“A”之外的元素。

CharacterArray = CharacterArray.filter(character => character !== 'A');

则 CharacterArray 必须为：['N'， 'B']

简单。只管去做：

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

我喜欢用来从数组中删除元素的两种最快方法：

1. 使用 方法仅删除第一个元素splice
2. 使用循环删除数组中匹配的所有元素for

const heartbreakerArray = ["😂","❤️","😍","❤️","❤️"]


// 1. If you want to remove only the first element from the array
const shallowCopy = Array.from(heartbreakerArray)
const index = shallowCopy.indexOf("❤️")
if (index > -1) { shallowCopy.splice(index, 1) }

console.log(shallowCopy) // Array(2) ["😂","😍","❤️","❤️"]


// 2. If you want to remove all matched elements from the array
const myOutputArray = []
const mySearchValue = "❤️"
for(let i = 0; i < heartbreakerArray.length; i++){
  if(heartbreakerArray[i]!==mySearchValue) {
    myOutputArray.push(heartbreakerArray[i])
  }
}

console.log(myOutputArray) // Array(2) ["😂","😍"]

您可以阅读详细的博客文章 在 JavaScript 中从数组中删除特定项的最快方法。

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

假设您要从 arr 中删除数字 3。

const newArr = arr.filter(w => w !==3)
console.log(newArr) // [ 1, 2, 4, 5 ]

如果您想要 [...].remove（el） 类语法，就像其他编程语言一样，那么你可以添加以下代码：

// Add remove method to Array prototype
Array.prototype.remove = function(value, count=this.length) {
    while(count > 0 && this.includes(value)) {
        this.splice(this.indexOf(value), 1);
        count--;
    }
    return this;
}

用法

// Original array
const arr = [1,2,2,3,2,5,6,7];

// Remove all 2s from array
arr.remove(2); // [1,3,5,6,7]

// Remove one 2 from beginning of array
arr.remove(2, 1); // [1,2,3,2,5,6,7]

// Remove two 2s from beginning of array
arr.remove(2, 2); // [1,3,2,5,6,7]

您可以根据需要操作该方法。

您可以简单地将 remove 函数添加到数组 protoType 中

像这样的东西：

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

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

let array = [10,15,20]

result = array.remove(10)
console.log(result)

let removeAnElement = (arr, element)=>{
    let findIndex = -1;
    for (let i = 0; i<(arr.length); i++){
        if(arr[i] === element){
            findIndex = i;
            break;
        }
    }
    if(findIndex == -1){
        return arr;
    }
    for (let i = findIndex; i<(arr.length-1); i++){
        arr[i] =  arr[i+1];
    }
    arr.length -= 1;
    return arr;
}

let array = ['apple', 'ball', 'cat', 'dog', 'egg'];
let removeElement = 'ball';

let tempArr2 = removeAnElement(array, 'dummy');
console.log(tempArr2);
// ['apple', 'cat', 'dog', 'egg']

let tempArr = removeAnElement(array, removeElement);
console.log(tempArr);`enter code here`
// ['apple', 'cat', 'dog', 'egg']

在 JavaScript 中，可以使用该方法从数组中删除特定值。Array.prototype.filter()

下面是一个示例：

let array = [1, 2, 3, 4, 5];
let value = 3;

array = array.filter(function(element) {
  return element !== value;
});

console.log(array); // Output: [1, 2, 4, 5]

在上面的代码中，我们首先创建一个数组并定义要删除的值。然后我们使用该方法创建一个新数组，该数组仅包含不等于给定值的元素。最后，我们将新数组赋值回原始数组变量。filter()

请注意，该方法创建一个新数组，而不是修改原始数组。如果要直接修改原始数组，可以使用 for 循环遍历数组并删除给定索引处的元素。filter()

下面是一个示例：

let array = [1, 2, 3, 4, 5];
let value = 3;

for (let i = 0; i < array.length; i++) {
  if (array[i] === value) {
    array.splice(i, 1);
    i--; // decrement i since the array has been modified
  }
}

console.log(array); // Output: [1, 2, 4, 5]

在此示例中，我们使用 a 遍历数组并检查每个元素是否等于给定值。如果是，我们使用 splice（） 方法删除当前索引处的元素。由于该方法修改了原始数组，因此我们递减以确保检查更新数组中的下一个元素。for loopsplice()i

我想把所有可能的解决方案都放在一起，并根据性能对其进行排名。放在上面的那个比最后一个更受欢迎。

对于所有方法，请考虑以下基本情况：

let arr = [1, 2, 3, 4, 5];
let elementToRemove = 4;
let indexToRemove = arr.indexOf(elementToRemove);

1. 使用方法：[最佳方法/高效splice()]

// When you don't know index
arr.splice(indexToRemove,1); // Remove a item at index of elementToRemove

// When you know index
arr.splice(3, 1); // Remove one item at index 3
console.log(arr); // Output: [1, 2, 3, 5]

2. 使用方法：[好方法filter()]

let filteredArr = arr.filter((num) => num !== elementToRemove);
console.log(filteredArr); // Output: [1, 2, 3, 5]

3. 使用方法：[Longer Approach（太多的表达式）slice()]

let newArr = arr.slice(0, indexToRemove).concat(arr.slice(indexToRemove + 1));
console.log(newArr); // Output: [1, 2, 3, 5]

4. 使用方法：[不推荐，因为它遍历每个元素forEach()]

let newArr = [];
arr.forEach((num) => {
  if(num !== elementToRemove){
    newArr.push(num);
  }
});
console.log(newArr); // Output: [1, 2, 3, 5]

我确实喜欢这个。

const arr = ["apple", "banana", "orange", "pear", "grape"];

const itemToRemove = "orange";

const filteredArr = arr.filter(item => item !== itemToRemove);

console.log(filteredArr); // ["apple", "banana", "pear", "grape"]

const arr = [2, 3, 1, 6];
const _index = arr.indexOf(3);
if (_index > -1) { // _index>-1 only when item exists in the array
  arr.splice(_index, 1);
}

使用 filter（）：filter（） 方法创建一个新数组，其中包含通过特定条件的所有元素。

您可以使用它来过滤掉要删除的特定项目。下面是一个示例：

const array = [1, 2, 3, 4, 5];
const itemToRemove = 3;

const filteredArray = array.filter(item => item !== itemToRemove);
console.log(filteredArray); 

// Output: [1, 2, 4, 5]

如果要创建一个新数组而不是就地修改原始数组，请使用 Array.prototype.toSpliced（）：

const index = array.indexOf(value);
const newArray = array.toSpliced(index, 1);

我将这些方法作为 Array 类型对象的扩展方法，您可以将它们添加到代码中，并像本机 Array 方法一样使用它们。

if (!Array.prototype.removeItem) {
    Object.defineProperty(Array.prototype, 'removeItem', {
        /**
         * Removing first instance of specified item by @value from array
         * @param {any} value
         * @returns
         */
        value: function (value) {
            var index = this.indexOf(value);
            if (index > -1)
                this.splice(index, 1);
            return this;
        }
    });
}

if (!Array.prototype.removeIndex) {
    Object.defineProperty(Array.prototype, 'removeIndex', {
        /**
         * Removing item at @index
         * @param {int} index
         * @returns
         */
        value: function (index) {
            if (index > -1)
                this.splice(index, 1);
            return this;
        }
    });
}

if (!Array.prototype.removeItems) {
    Object.defineProperty(Array.prototype, 'removeItems', {
        /**
         * Removing all items like @value .\n
         * If @value is null this function will removes all items
         * @param {any} value
         * @returns
         */
        value: function (value) {
            if (value == null)
                return [];
            else {
                let i = 0;
                while (i < this.length) {
                    if (this[i] === value)
                        this.splice(i, 1);
                    else
                        ++i;
                }
            }
            return this;
        }
    });
}

如果要避免直接修改原始数组，请使用 Array.prototype.toSpliced（）。 不过，请注意其目前对浏览器的支持有限。

const stocks = ["Microsoft", "Nvidia", "Amazon"]
const copy = stocks.toSpliced(0, 1, "Alphabet")

console.log("Copy", copy)
console.log("Original", stocks)

我找到了另一种从数组
中删除特定项目的方法 在下面的示例中，我从列表中删除了“2”。

1. 如果数组包含重复值，例如 [1,2,3,4,2,2,1,1,2]

var arr = [1,2,3,4,2,2,1,1,2];
console.log(arr.filter((e)=>e!=2));

2.如果数组不包含重复值，例如。[1,2,3,4,5]

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

主要有两种情况：

• 您想要删除第一个匹配项
• 您想要删除所有匹配项

删除第一个匹配项

let array = ['a', 'b', 'c', 'd', 'c', 'e', 'f', 'g'];
array = array.filter((item, ind) => (ind != array.indexOf('c')));
console.log(array);

我们只需找到 c 的索引并将其过滤掉即可。当然，为了加快速度，我们可以在调用之前进行计算。.indexOf.filter()

删除所有匹配项

let array = ['a', 'b', 'c', 'd', 'c', 'e', 'f', 'g'];
array = array.filter(item => (item !== 'c'));
console.log(array);