从javascript数组中删除元素的干净方法（使用jQuery、coffeescript）

关于这一点，有很多问题，尤其是： ，还有更多。然而，它们看起来都很复杂和烦人

结合javascript、jQuery和coffeescript的强大功能，从javascript数组中删除元素的最干净方法是什么？我们事先不知道指数。代码：

a = [4,8,2,3]
a.remove(8)     # a is now [4,2,3]

---

如果没有一个好的内置方法，那么扩展javascript数组以支持这种方法的干净方法是什么？如果有帮助的话，我真的使用数组作为集合。理想情况下，解决方案将在带有jQuery支持的coffeescript中很好地工作。此外，我不能不关心速度，而是优先考虑清晰、简单的代码。

使用普通Javascript：

Array.prototype.remove = function(elem) {
    var match = -1;

    while( (match = this.indexOf(elem)) > -1 ) {
        this.splice(match, 1);
    }
};

var a = [4, 8, 2, 3];

a.remove(8);

Array.prototype.remove = function(e) {
  var t, _ref;
  if ((t = this.indexOf(e)) > -1) {
    return ([].splice.apply(this, [t, t - t + 1].concat(_ref = [])), _ref);
  }};

仅jQuery：

jQuery.removeFromArray = function(value, arr) {
    return jQuery.grep(arr, function(elem, index) {
        return elem !== value;
    });
};

var a = [4, 8, 2, 3];

a = jQuery.removeFromArray(8, a);

---

这看起来很干净，可以理解；与其他答案不同，它考虑了元素多次出现的可能性

Array.prototype.remove = function (value) {
    for (var i = 0; i < this.length; ) {
        if (this[i] === value) {
            this.splice(i, 1);
        } else {
           ++i;
        }
    }
}

Array.prototype.remove=函数（值）{
对于（var i=0；i

在咖啡脚本中：

Array::remove = (value) ->
    i = 0
    while i < @length
        if @[i] == value
            @splice i, 1
        else
            ++i
    return @

Array::remove = (e) -> @[t..t] = [] if (t = @indexOf(e)) > -1

Array:：remove=（值）->
i=0
而我<@length
如果@[i]==值
@拼接i，1
其他的
++我
返回@

咖啡脚本：

Array::remove = (value) ->
    i = 0
    while i < @length
        if @[i] == value
            @splice i, 1
        else
            ++i
    return @

Array::remove = (e) -> @[t..t] = [] if (t = @indexOf(e)) > -1

它只是将元素拼接到位置

t

，即找到

e

的索引处（如果实际找到

t>-1

）。Coffeescript将此转换为：

Array.prototype.remove = function(e) {
    var t, _ref;
    if ((t = this.indexOf(e)) > -1) {
        return ([].splice.apply(this, [t, t - t + 1].concat(_ref = [])), _ref);
    }
};

如果要删除所有匹配元素，并使用CoffeeScript和jQuery返回新数组：

Array::remove = (v) -> $.grep @,(e)->e!=v

也就是说：

Array.prototype.remove = function(v) {
    return $.grep(this, function(e) {
        return e !== v;
    });
};

或者在没有jQuery的grep的情况下执行相同的操作：

Array::filterOutValue = (v) -> x for x in @ when x!=v

也就是说：

Array.prototype.filterOutValue = function(v) {
    var x, _i, _len, _results;
    _results = [];
    for (_i = 0, _len = this.length; _i < _len; _i++) {
        x = this[_i];
        if (x !== v) {
            _results.push(x);
        }
    }
    return _results;
};

Array.prototype.filterOutValue=函数（v）{
变量x，i，len，结果；
_结果=[]；
对于（_i=0，_len=this.length；_i<_len；_i++）{
x=这个[_i]；
如果（x！==v）{
_结果：推（x）；
}
}
返回结果；
};

这只是对以下内容的一个小小更改：

如果列表中有元素，则返回该元素，因此可以执行以下操作：

do_something 100 if a.remove(100)

remove coffee脚本转换为以下javascript：

Array.prototype.remove = function(elem) {
    var match = -1;

    while( (match = this.indexOf(elem)) > -1 ) {
        this.splice(match, 1);
    }
};

var a = [4, 8, 2, 3];

a.remove(8);

Array.prototype.remove = function(e) {
  var t, _ref;
  if ((t = this.indexOf(e)) > -1) {
    return ([].splice.apply(this, [t, t - t + 1].concat(_ref = [])), _ref);
  }};

---

如果您也在使用CoffeeScript creator的库，那么这里有一行代码可以很好地工作：

a = _(a).reject (v)-> v is e

或在js中：

a = _(a).reject(function(v) { return v == e; });

---

这对于jQuery来说非常简单：

var index = $.inArray("value", myArray);
if(index != -1)
{
  myArray.splice(index, 1);
}

注:

splice

返回已删除的元素，因此不要执行

myArray=myArray.splice（）

<代码>myArray.splice（索引，1）表示“从数组中删除索引处的数组元素”

---

$.inArray

返回要查找的值在数组中的索引，如果该值不在数组中，则返回-1

您可以试试jQuery的grep实用程序：

a = [4,8,2,3]
$.grep(a,function(v){return v!=8;})

---

这里可能存在性能问题，因为您在技术上导致变量引用新数组；你并不是真的在修改原来的。假设原始文件没有在其他地方引用，垃圾回收器应该很快地完成这项工作。这对我来说从来都不是一个问题，但其他人可能更清楚。干杯

尽管您要求使用Coffeescript或jQuery的干净方法，但我发现最干净的方法是使用vanilla javascript方法：

它在咖啡稿中看起来更干净，但是这转化为完全相同的JavaScript，所以我只把它视为视觉上的差异，而不是咖啡稿的一个高级特征：

array.filter (item) -> item isnt match

传统浏览器不支持过滤器，但Mozilla提供了符合ECMA标准的过滤器。我认为这是一种非常安全的方法，因为您只是将旧的浏览器引入现代标准，并且没有在polyfill中发明任何新功能

很抱歉，如果您专门寻找jQuery或Coffeescript-only方法，但我认为您主要是在寻找库方法，因为您不知道干净的javascript-only方法

---

你有它，没有图书馆需要

虽然我当然应该进行基准测试，但我怀疑这会比较慢，因为

indexOf

是O（n），这会使m的总复杂度为O（n*m+n）。我的答案只通过了一次，给出了O（n）复杂度。@Domenic:当然

.index（）

没有那么快，但它足够公平，代码更少。如果我是在追求性能，我会使用

while（）

循环：看，哈哈，你的jsPerf揭示了Chrome和Firefox 4b10之间的差异，很好！

for

版本在我的Firefox中运行的速度明显快于你的Chrome浏览器。酷@多梅尼克：的确很奇怪。很明显，你使用咖啡脚本的时间比我长得多+感谢@Amir给出了一个非常地道的回答。其他答案也很有帮助；我喜欢这个，因为它使用可用的工具使事情变得更简单。一个小改动：我可能会称之为

Array:：removing

，就像

较小的数组=较大的数组。移除（某物）

，所以很明显它会返回一个新数组。该死的咖啡脚本真漂亮。我相信你可以去掉@indexOf，只做@indexOf（无点）。去掉不必要的

concat

：

Array:：remove=（v）->拼接I，如果I=@indexOf（v）>-1

，多亏了这个

$.grep@，（e）->e=v

我再也不会考虑使用咖啡脚本了。可读性等于零。这几乎和vanilla JS一样简单，似乎只删除一个匹配的条目。一个数组可以包含多个相同值的条目。问题是：“从javascript数组中删除元素的最干净的方法是什么？”我喜欢这种方法和推理。