繁体   English   中英

如何从数组中删除特定项目?

How can I remove a specific item from an array?

提示:本站收集StackOverFlow近2千万问答,支持中英文搜索,鼠标放在语句上弹窗显示对应的参考中文或英文, 本站还提供   中文繁体   英文版本   中英对照 版本,有任何建议请联系yoyou2525@163.com。

如何从数组中删除特定值? 就像是:

array.remove(value);  // removes all elements with value

我必须使用核心JavaScript。 不允许使用框架。

137 个回复

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

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

splice的第二个参数是要移除的元素的数量。 请注意, splice会修改数组并返回一个包含已删除元素的新数组。


为了完整起见,这里是函数。 第一个函数只删除一个匹配项(即从[2,5,9,1,5,8,5]删除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;
}

2016 年 10 月编辑

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

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

删除项目(ECMA-262 Edition 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 ]

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

重要array.includes(...)函数在 Internet Explorer、47 版之前的 Chrome、43 版之前的 Firefox、9 版之前的 Safari 和 14 版之前的 Edge 中根本不支持,但您可以使用core-js

删除多个项目(将来可能)

如果曾经接受过“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.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];

这取决于您是否要保留一个空白点。

如果您确实想要一个空插槽:

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()对第一个使用 array.shift() (两者都返回项目的值)。

如果您不知道项目的索引,可以使用array.indexOf(item)来获取它(在if()中获取一个项目或在while()中获取所有项目)。 array.indexOf(item)返回索引或者-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);
   }
}

它向后循环遍历数组(因为索引和长度会随着项目的删除而改变)并在找到项目时将其删除。 它适用于所有浏览器。

有两种主要方法

  1. splice() : 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

对数组使用delete时要小心。 它适用于删除对象的属性,但不适用于数组。 最好对数组使用splice

请记住,当您对数组使用delete时,您可能会得到anArray.length的错误结果。 换句话说, delete会删除元素,但不会更新 length 属性的值。

您还可以预期在使用 delete 之后索引号会出现漏洞,例如,您最终可能会得到索引 1、3、4、8、9 和 11 以及使用 delete 之前的长度。 在这种情况下,所有索引for循环都会崩溃,因为索引不再是连续的。

如果由于某种原因您被迫使用delete ,那么当您需要遍历数组时,您应该使用for each循环。 事实上,如果可能,请始终避免使用索引for循环。 这样,代码会更健壮,更不容易出现索引问题。

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

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

查找和移动(移动):

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

使用indexOfsplice (indexof):

function indexof(arr, val) {
  var i;
  while ((i = arr.indexOf(val)) != -1) {
    arr.splice(i, 1);
  }
}

只使用splice (splice):

function splice(arr, val) {
  for (var i = arr.length; i--;) {
    if (arr[i] === val) {
      arr.splice(i, 1);
    }
  }
}

具有 1000 个元素的数组在 nodejs 上的运行时间(平均超过 10000 次运行):

indexofmove慢大约 10 倍。 即使通过删除splice中对indexOf的调用来改进它,它的性能也比move差得多。

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

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

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

用法

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

您可以使用filter方法轻松完成:

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

这会从数组中删除所有元素,并且比sliceindexOf的组合工作得更快。

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 的原始实现没有这个问题。

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

Underscore.js可用于解决多个浏览器的问题。 如果存在,它使用内置浏览器方法。 如果它们像旧 Internet Explorer 版本一样不存在,它会使用自己的自定义方法。

从数组中删除元素的一个简单示例(来自网站):

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

如果您想要一个删除了已删除位置的新数组,您始终可以删除特定元素并过滤掉该数组。 对于没有实现过滤器方法的浏览器,它可能需要扩展数组对象,但从长远来看,它会更容易,因为你所做的就是:

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]

以下是使用 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/

查看此代码。 它适用于所有主流浏览器

 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)

您可以使用 lodash _.pull (变异数组)、_. pullAt (变异数组)或_.without (不变异数组),

var array1 = ['a', 'b', 'c', 'd']
_.pull(array1, 'c')
console.log(array1) // ['a', 'b', 'd']

var array2 = ['e', 'f', 'g', 'h']
_.pullAt(array2, 0)
console.log(array2) // ['f', 'g', 'h']

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']

从数组中删除特定元素/字符串可以在单行中完成:

theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

在哪里:

theArray :要从中删除特定内容的数组

stringToRemoveFromArray :要删除的字符串,1 是要删除的元素数。

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

在删除它之前首先检查元素是否存在于数组中始终是一个好习惯。

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

使用过滤器是实现此要求的一种优雅方式

 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]

如果您只想删除第一次出现,可以使用Array.prototype.splice()方法

 const num = 3; let arr = [1, 2, 3, 3, 3, 4]; arr.splice(arr.indexOf(num), 1); console.log(arr); // [1, 2, 3, 3, 4]

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)

ES10

这篇文章总结了截至ECMAScript 2019 (ES10) 从数组中删除元素的常用方法。

一、一般情况

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. 使用.filter()方法删除 Array 元素

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

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

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.prototype移除 Array 元素

| 就地:是/否(取决于实施)|
| 删除重复项:是/否(取决于实施)|
| 按值/索引:按索引/按值(取决于实施)|

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. 使用delete运算符删除数组元素

| 就地:是 |
| 删除重复项:否 |
| 按值/索引:按索引 |

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

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]

删除运算符旨在从 JavaScript 对象中删除属性,其中数组是对象。

1.5。 使用Object实用程序删除数组元素 (>= ES10)

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

ES10 引入了Object.fromEntries ,可用于从任何类似 Array 的对象创建所需的 Array 并在此过程中过滤不需要的元素。

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。 更改数组length

| 就地:是 |
| 删除重复项:否 |
| 按价值/指数:不适用 |

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

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

| 就地:是 |
| 删除重复项:否 |
| 按价值/指数:不适用 |

pop 方法删除数组的最后一个元素,返回该元素,并更新长度属性。 pop 方法修改了调用它的数组,这意味着与使用 delete 不同,最后一个元素被完全删除并减少了数组长度。

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

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

| 就地:是 |
| 删除重复项:否 |
| 按价值/指数:不适用 |

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

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

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

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

最快的技术是将数组变量设置为空数组。

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

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

表现

今天 (2019-12-09) 我在 macOS v10.13.6 (High Sierra) 上针对选定的解决方案进行性能测试。 我显示了delete (A),但与其他方法相比,我不使用它,因为它在数组中留下了空白空间。

结论

  • 最快的解决方案是array.splice (C) (除了 Safari 的小数组,它有第二次)
  • 对于大数组, array.slice+splice (H) 是 Firefox 和 Safari 最快的不可变解决方案; Array.from (B) 在 Chrome 中是最快的
  • 可变解决方案通常比不可变解决方案快 1.5 倍至 6 倍
  • 对于 Safari 上的小表,令人惊讶的是,可变解决方案 (C) 比不可变解决方案 (G) 慢

细节

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

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

在此处输入图像描述

在 Chrome 中, array.splice (C) 是最快的就地解决方案。 array.filter (D) 是最快的不可变解决方案。 最慢的是array.slice (F)。 您可以在此处在您的机器上执行测试。

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

在此处输入图像描述

在 Chrome 中, array.splice (C) 是最快的就地解决方案( delete (C) 的速度类似 - 但它在数组中留下了一个空槽(因此它不会执行“完全删除”))。 array.slice-splice (H) 是最快的不可变解决方案。 最慢的是array.filter (D和E)。 您可以在此处在您的机器上执行测试。

 var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; var log = (letter,array) => console.log(letter, array.join `,`); 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

在此处输入图像描述

好的,例如你有下面的数组:

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。

我对 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”]

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

我想根据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]

提示:除非你得到一个空数组,否则请使用箭头函数进行过滤回调。

更新:仅当您无法使用 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]

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

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

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

你永远不应该改变你的数组,因为这违反了函数式编程模式。 您可以使用 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

为了进一步了解,您可以阅读 MDN 文档Array.filter

如果元素有多个实例,您可以执行反向循环以确保不会搞砸索引。

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

现场演示

一种更现代的ECMAScript 2015 (以前称为 Harmony 或 ES 6)方法。 鉴于:

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

然后:

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

产量:

[1, 2, 4]

您可以使用Babelpolyfill 服务来确保跨浏览器很好地支持这一点。

数组中有 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);

包括支持的浏览器是链接

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

一种不可变的单行方式:

const newArr = targetArr.filter(e => e !== elementToDelete);

演示截图

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

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

动画可视化 array.prototype.filter

注意事项

代码质量

在这种情况下, Array.prototype.filter是删除数字的最易读的方法。 它几乎没有出错的余地,并使用核心 JS 功能。

为什么不是array.prototype.map

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

支持

截至今天(11.4.2022),94.08% 的互联网用户浏览器支持array.prototype.filter。 所以一般来说使用是安全的。 但是,IE6 - 8 不支持它。 因此,如果您的用例需要对这些浏览器的支持,那么 Chris Ferdinanti 制作了一个不错的polyfill

表现

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

不同可能性的基准: https ://jsben.ch/C5MXz

使用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]

我知道已经有很多答案,但其中许多似乎使问题过于复杂。 这是删除键的所有实例的简单递归方法 - 调用 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);
}

我喜欢这个单行:

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 array = [1, 2, 3, 4, 511, 34, 511, 78, 88];

let value = 511;
array = array.filter(element => element !== value);
console.log(array)

创建新数组:

var my_array = new Array();

向该数组添加元素:

my_array.push("element1");

函数 indexOf (返回索引或未找到时 -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);

基于所有主要正确的答案并考虑到建议的最佳实践(尤其是不直接使用 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 的情况进行了比较,如果浏览器支持Map ,它会胜过 lodash! 请注意,我没有使用Array.prototype.indexOfArray.prototype.includes因为将 exlcudeValues 包装在MapObject中可以加快查询速度!

我有另一个从数组中删除的好解决方案:

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

我测试了splicefilter ,看看哪个更快:

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

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

也就是说, filter在逻辑上更清晰(更易于阅读)并且更适合使用不可变状态的编码风格。 因此,是否要进行权衡取决于您。

我还遇到了必须从Array中删除元素的情况。 .indexOf在 Internet Explorer 中不起作用,所以我分享了我的工作jQuery.inArray()解决方案:

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

按索引删除

一个返回没有索引元素的数组副本的函数:

/**
* 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 ]

按值删除

返回没有值的数组副本的函数。

/**
* 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]

您可以遍历每个array -item 并splice它(如果它存在于您的array中)。

function destroy(arr, val) {
    for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
    return arr;
}

通常最好使用filter函数创建一个新数组。

let array = [1,2,3,4];
array = array.filter(i => i !== 4); // [1,2,3]

这也提高了可读性恕我直言。 我不是slice的粉丝,虽然它知道有时你应该去追求它。

我认为许多 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))

我相信在适当的函数式语言中,改变它所调用的对象的方法必须返回对这个对象的引用作为结果。

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),您也可以使用自定义比较器。

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

咖啡脚本中:

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

删除索引 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);
}
[2,3,5].filter(i => ![5].includes(i))

你有一个整数数组,而不是键是这些整数的字符串等价物的对象,真是太可惜了。

我已经浏览了很多这些答案,据我所知,它们似乎都在使用“蛮力”。 我没有检查每一个,如果不是这样道歉。 对于一个较小的数组,这很好,但如果你有 000 个整数呢?

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

我只是建议,在某些情况下,最好的解决方案可能是将您的数组转换为一个对象......当然,问题在于您可能有重复的整数值。 我建议将它们放在桶中作为key => value条目的“值”部分。 (注意:如果您确定没有任何重复的数组元素,这可以更简单:值“与”键相同,只需转到Object.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 个空槽>,还有 46 个……]

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

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

您不必全部删除它们:索引值按出现顺序被推入它们的存储桶中,因此(例如):

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

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

从您的“桶对象”中检索修改后的int数组稍微有点复杂,但并不多:每个桶都包含由 ( string ) 键表示的值的索引(在原始数组中)。 这些桶值中的每一个也是唯一的(每个都是原始数组中的唯一索引值):因此您将它们转换为新对象中的键,并将“整数字符串键”中的(实际)整数作为值......然后对键进行排序并转到Object.values( ... )

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

附录如果您确定这对于您的用例来说太多工程了,那么最简单的“蛮力”方法肯定是

const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )

(是的,其他答案已经发现Array.prototype.filter ...)

 var array = [2, 5, 9]; var res = array.splice(array.findIndex(x => x==5), 1); console.log(res)

使用 Array.findindex,我们可以减少代码行数。

developer.mozilla.org

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

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

splice() 方法

array.splice(index, 1);    

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

所以对于单个元素,我们使用 1。

删除方法

delete array[index]

filter() 方法

如果要删除在数组中重复的元素,请过滤数组:

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

其中elem是您要从数组中删除的元素,而array是您的数组名称。

要从字符串数组中查找和删除特定字符串:

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

最简单的方法可能是使用过滤器功能。 这是一个例子:

 let array = ["hello", "world"] let newarray = array.filter(item => item !== "hello"); console.log(newarray); // ["world"]

使用 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 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();
}

我发现这篇博客文章展示了九种方法:

从 JavaScript 数组中删除元素的 9 种方法 - 以及如何安全地清除 JavaScript 数组

我更喜欢使用filter()

var filtered_arr = arr.filter(function(ele){
   return ele != value;
})

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

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

明白此事:

您可以使用 JavaScript 数组对值进行分组并对其进行迭代。 可以通过多种方式添加和删除数组项。 总共有 9 种方法(使用任何适合您的方法)。 JavaScript 数组没有删除方法,而是有多种方法可以清除数组值。

执行此操作的不同技术方法:

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

1-pop:从数组的末尾移除。

2-shift:从数组的开头删除。

3-splice:从特定的 Array 索引中删除。

4-过滤器:这允许您以编程方式从数组中删除元素。


方法 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]

方法三:在 JavaScript 中使用 Splice 移除数组元素

 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:使用 Splice 按值删除数组项

 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:制作删除方法

 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 removeArrValue(arr,value) {
    var index = arr.indexOf(value);
    if (index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}

通过我的解决方案,由于纯 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;
}

我对基本 JavaScript 数组进行了相当有效的扩展:

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

删除一个值,使用松散比较,不改变原始数组,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;
}

非就地解决方案

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

您可以使用所有访问器示例创建索引:

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

这里的大多数答案都使用 -

  1. indexOf 和拼接
  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方法。

我喜欢这个版本的拼接,使用$.inArray按其值删除元素:

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

使用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>

虽然前面的大多数答案都回答了这个问题,但还不清楚为什么没有使用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);

您的问题没有表明是否需要顺序或不同的值。

如果您不关心顺序,并且容器中不会多次具有相同的值,请使用 Set。 它会更快,更简洁。

var aSet = new Set();

aSet.add(1);
aSet.add(2);
aSet.add(3);

aSet.delete(2);

从最后一个元素删除

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

您可以使用splice从数组中删除对象或值。

让我们考虑一个长度为5的数组,其值为1020304050 ,我想从中删除值30

 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]

如果数组包含重复值并且您想删除所有出现的目标,那么这就是要走的路...

let data = [2, 5, 9, 2, 8, 5, 9, 5];
let target = 5;
data = data.filter(da => da !== target);

注意: - 过滤器不会改变原始数组; 相反,它会创建一个新数组。

所以重新分配很重要。

这导致了另一个问题。 你不能使变量const 它应该是letvar

此函数从特定位置从数组中删除一个元素。

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

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

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

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

  1. 删除所有事件。

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

  1. 使用加入和拆分

     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)

删除最后一次出现或所有出现,或第一次出现?

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

我刚刚通过Object.definePropertyArray.prototype上创建了一个 polyfill,以删除数组中所需的元素,而在稍后通过for .. 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.remove方法删除数组内的对象。 您只需要指定要删除的Objectkey => value

删除对象值

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

使用 .indexOf() 和 .splice() - 可变模式

这里有两种情况:

  1. 我们知道索引

 const drinks = [ 'Tea', 'Coffee', 'Milk']; const id = 1; const removedDrink = drinks.splice(id, 1); console.log(removedDrink)

  1. 我们不知道索引,但知道值。
     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);

如果您使用的是现代浏览器,则可以使用 .filter。

 Array.prototype.remove = function(x){ return this.filter(function(v){ return v !== x; }); }; var a = ["a","b","c"]; var b = a.remove('a');

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

这是我在数组使用拼接方法中删除特定数据的简单代码。 splice 方法会给出 2 个参数,第一个参数是起始编号,第二个参数是 deleteCount。 第二个参数用于从第一个参数的值开始删除一些元素。

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

arr.splice(0,2);

console.log(arr);

对于希望复制将返回删除重复数字或字符串的新数组的方法的任何人,这已从现有答案中汇总:

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

一个非常幼稚的实现如下:

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

对我来说,越简单越好,就像我们在 2018 年(接近 2019 年)一样,我给你这个(接近)单行字来回答最初的问题:

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

有用的是您可以在 curry 表达式中使用它,例如:

[1,2,3].remove(2).sort()

删除单个元素

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)

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

  • pop - 从数组末尾删除
  • shift - 从数组的开头删除
  • splice - 从特定的 Array 索引中删除
  • filter - 允许您以编程方式从数组中删除元素

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

有很多方法可以从 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/lodash@4.17.21/lodash.min.js"></script>

5.制作自定义remove方法

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 种)更适合解决上述问题。

您可以添加一个原型函数来“删除”数组中的元素。

下面的示例展示了当我们知道元素的索引时,如何简单地从数组中删除元素。 我们在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);

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;

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

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

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

array.key = null;

以下方法将从数组中删除给定值的所有条目,而无需创建新数组并且仅进行一次超快迭代。 它适用于古老的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>

使用 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
>

要删除特定元素或后续元素, Array.splice()方法效果很好。

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

语法: array.splice(index, deleteCount, item1, ....., itemX)

这里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]

    或者假设我们想从数组arr中删除del

     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]

最干净的:

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

这也将删除重复项(如果有)。

仅从年龄中删除前34岁,而不是所有年龄34

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

删除所有年龄34

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

如果您必须支持旧版本的 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

我自己也遇到了这个问题(在可以替换数组的情况下)并用一个简单的方法解决了它:

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

此解决方案应该适用于参考和价值项目。 这完全取决于您是否需要维护对原始数组的引用,以确定该解决方案是否适用。

您只需要按元素或索引过滤:

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

您可以改用Set并使用delete功能:

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

从数组中删除项目的最佳方法是用户过滤方法。 .filter() 返回没有过滤项的新数组。

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

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

定义:

JavaScript 数组允许您对值进行分组并对其进行迭代。 您可以通过不同的方式添加和删除数组元素。 不幸的是,没有简单的 Array.remove 方法。 总共有9 种方法(使用任何适合您的方法)。 JavaScript 数组没有删除方法,而是有多种方法可以清除数组值。

您可以使用不同的方法和技术从 JavaScript 数组中删除元素:

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

  • pop - 从数组末尾删除
  • shift - 从数组的开头删除
  • splice - 从特定的 Array 索引中删除
  • filter - 允许您以编程方式从数组中删除元素

方法 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 中使用 Splice 删除数组元素

 var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]; var removed = arr.splice(2,2); console.log(arr); var list = ["bar", "baz", "foo", "qux"]; list.splice(0, 2); console.log(list);

方法 4 :使用 Splice 按值删除数组项

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

方法5 :使用数组过滤方法按值删除项目

 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(filtered); // 6 is removed

方法 6 :Lodash 数组删除方法

 var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; var removeElement = _.remove(array, function(n) { return n === 6; }); console.log(array); // 6 is removed
 <script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>

方法 7 :制作删除方法

 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(arrayRemove(array, 6)); // 6 is removed

方法 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 数组项以管理数据很重要。 没有单一的“删除”方法,但您可以使用多种方法和技术来清理不需要的数组项。

您可以扩展数组对象以定义自定义删除函数,如下所示:

 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

我想建议使用删除和过滤器删除一个数组项:

 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)

因此,我们可以只删除一个特定的数组项,而不是删除具有相同值的所有项。

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

已经有很多答案了,但是因为还没有人用一个班轮做到这一点,所以我想我会展示我的方法。 它利用了 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("-") 函数将您的字符串不正确地拼凑在一起。 在这种情况下,上述片段中的所有“-”字符串都可以替换为原始数组中不会使用的任何字符串。 这是另一个例子:

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

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

startend可以是负数。 在这种情况下,它们从数组的末尾开始计数。

如果只指定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]

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

arr.splice(0,1)

console.log(arr)

输出 [2, 3, 4, 5];

splice()方法通过删除或替换现有元素和/或添加新元素来更改数组的内容。

array.splice(start[, deleteCount[, item1[, item2[, ...]]]])

开始

开始更改数组的索引(原点为 0)。 如果大于数组的长度,实际的起始索引将设置为数组的长度。 如果为负数,它将从数组末尾开始很多元素(原点 -1),如果绝对值大于数组的长度,则将其设置为 0。

deleteCount 可选

一个整数,指示要删除的旧数组元素的数量。

如果 deleteCount 被省略,或者它的值大于 array.length - start (即,如果它大于数组中剩余的元素数,从 start 开始),那么从 start 到 end 的所有元素的数组将被删除。 如果 deleteCount 为 0 或负数,则不删除任何元素。 在这种情况下,您应该至少指定一个新元素(见下文)。

item1, item2, ... 可选

要添加到数组的元素,从起始索引开始。 如果不指定任何元素, splice() 只会从数组中删除元素。

如需更多参考资料,请浏览:

Array.prototype.splice()

止盈减少方法如下:

案例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] : []), []);
}

因此,通过这种方式,我们可以返回一个新数组(将以一种很酷的功能方式 - 比使用 push 或 splice 更好)并删除元素。

  1. 获取数组和索引
  2. 从带有数组元素的arraylist
  3. 使用remove()方法删除特定索引元素
  4. 使用maptoint()toarray()方法从数组列表的新数组
  5. 返回格式化的数组

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

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]

这取决于您是否要保留一个空白点。

如果您确实想要一个空插槽:

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() 中获取所有项目)。 array.indexOf(item)返回索引或者 -1 如果没有找到。

罗达什

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

最基本的解决方案是:

array.key = null;

除了所有这些解决方案之外,还可以使用 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]
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)

有多种方法可以做到这一点,你希望它如何行动

一种方法是使用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]
const newArray = oldArray.filter(item => item !== removeItem);

定义:

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

通过传递它的值来删除一个项目-

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

}

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

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

您可以在 javascript 中以多种方式完成此任务

  1. 如果您知道值的索引:在这种情况下,您可以使用 splice
var arr = [1,2,3,4]
// let's say we have the index, comming from some api
let index = 2;
// splice is a destructive method and modifies the original array
arr.splice(2, 1)
  1. 如果您没有索引而只有值:在这种情况下,您可以使用 filter
// let's remove 2 for example 
arr = arr.filter((value)=>{
    return value !== 2;
})

简单就行:

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

例如,您有字符数组并想从数组中删除“A”。

Array 有 filter 方法,它可以过滤并只返回你想要的元素。

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

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

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

那么 CharacterArray 必须是:['N', 'B']

我喜欢从数组中删除元素的 2 种最快方法。

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

 const heartbreakerArray = ["","❤️","","❤️","❤️"] // 1. If you want to remove only 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 each element of 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) ["",""]

您可以阅读以下 URL、 https://javascript.plainenglish.io/how-to-remove-a-specific-item-from-an-array-in-javascript-a49b108404c的详细博文

 const Delete = (id) => {
      console.log(id)
     var index = Array.map(function(e){
      return e.id;
     
     }).indexOf(id);
     Array.splice(index,1);
     
}

您可以使用

Array.splice(index);

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

例如:

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]

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

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

let array = [5,5,4,4,2,3,4]    
let newArray = array.join(',').replace('5','').split(',')

如果您想删除一个当前项目,则此示例有效。

1 从数组中删除特定项目

我正在使用以下功能将项目保存到本地存储中的数组中。 一旦存储了一个项目,我想通过再次选择保存按钮将其从阵列中删除。 当前,用户可以多次保存同一项目。 通过修改保存按钮以删除项目,用户将有一种简便的方法来删除项目,这将防止他们多次保存同一项目。 我应该如何在该函数的基础上允许我执行此 ...

2 如何删除(删除)对象数组中的特定项目

我想使用删除功能删除数组中的特定对象。 我尝试了splice()方法,但是无论我单击哪个对象,它都只会删除第一个数组 这是使用v-for方法的对象的代码 这是Skill.vue }; 我该如何构造方法 删除特定对象? ...

3 从Vuex中的数组中删除特定项目

我仍在学习vue.js的过程中,还在一个小项目的中间,以帮助我学习有关使用Vuex创建更大规模的应用程序的更多信息。 我遇到了一个问题,我试图使用应用程序中的按钮从数组中删除特定项目; 我似乎在Vuex中没有正确的语法来做到这一点。 这是我正在使用的: 商店 行动 ...

4 从数组中删除特定项目会删除 UI 中的错误项目

我为此苦苦挣扎了几天,但无法弄清楚。 我有一个简单的小部件,我想在其中动态添加和删除输入(对于集合/代表)。 问题是,如果我要删除第一项,那么最后一项会从 UI 中删除。 我为应用程序创建了一个飞镖板: dartpad 我的 main.dart: 问题: ...

5 如何快速删除数组中的特定项目?

我正在使用一个充满结构的数组: 现在,我试图从阵列中删除其中之一。 我尝试使用fullCart.index(of:) ,但这给了我以下错误: 参数标签'(of :, _ :)'与任何可用的重载都不匹配 我希望使用fullCart.remove(at:) ,但是由于找不 ...

6 无法删除数组中的特定项目

我有一个包含以下项( content )的数组: 我想删除另一个数组中具有特定ID的所有项目,例如: $to_remove = ["53", "54", "60"] ,我所做的是: 问题是最终结果中我有: 为什么? ...

2019-01-21 21:35:36 3 47   php
7 我想从数组中删除特定项目

我在舞台 [a,b,c.....i] 中有 9 个 mc,并且每个 mc 的itemIndex[]内容索引,我想从itemIndex[]中删除一个特定项目,但我发现的问题是当我一遍又一遍地点击同一个 mc 时,其他项目继续从 itemIndex[] 中删除; 导入 flash.events.Mous ...

8 使用值从数组中删除特定项

这是我的代码。 我想通过使用它们的值或 id 从下面删除一个项目。 我怎样才能做到这一点。 有没有办法在不过滤数组的情况下做到这一点。 ...

10 我无法从此数组中删除此特定项目

我知道这很简单,但是尝试搜索却找不到能解决我问题的任何东西。 所以说我有这个数组: 我想删除25000以外的所有内容。因此,我尝试了一个简单的迭代: 而且它不起作用。 输出为[45,5000,25000,150000],不知道为什么。 ...

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2022 STACKOOM.COM