我建议删除一个使用删除和过滤的阵列项目:

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)

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

我喜欢这个单行道:

arr.includes(val) && arr.splice(arr.indexOf(val), 1)

• 欧 6(无 (没有) (没有) (没有) (没有)Internet 探索器支助))
• 在原地清除。
• 快速: 不重复重复重复或重复 。
• 支持删除这些值null或undefined

作为原型

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

(是的,我读了所有其他的答案 却找不到一个结合的答案)includes和splice在同一行中。 )

业绩 业绩业绩 业绩业绩

今天(2019-12-09),我为选择的解决方案对macOS v10.13.6(高塞拉利昂)进行性能测试。delete(A),但与其他方法相比,我并不使用它,因为它在数组中留下了空白。

结 结 结 结 结 结 结

• 最快的解决方案是array.splice(C) (小型阵列有第二次的Safeare除外)
• 以大数组盟誓,array.slice+splice(H) 是Firefox和Safari最快、不可改变的解决办法;Array.from(B) 铬含量最快
• 可变溶液通常比不可变的更快1.5x-6x
• 令人惊讶的是,变异解决办法(C)慢于不可变解决办法(G)

详细细节

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

包含 10 元素的阵列结果

在铬array.splice(C) 是当地最快的解决办法。array.filter(D) 是最快、不可改变的解决方案。array.slice(F). 您可以在机器上进行测试在这里.

带有 1 000 000 元素的阵列结果

在铬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 v.13.0.4和Firefox v71.0.0

这里有很多奇妙的答案, 但对我来说,最有效的答案 不是完全从阵列中移除我的元素, 而是简单地设定它的价值为无效。

这对大多数情况都有效,而且是一个很好的解决方案,因为我稍后会使用变量,而不想让变量消失,只是暂时空的。此外,这个方法完全可以交叉浏览。

array.key = null;

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

提示提示:请使用箭头函数进行过滤回击,除非您得到空数组。

检查一下这个代码 每个代码都有效主浏览器.

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)