ECMAScript 6有一个很好的查找建议。

find方法对每个元素执行一次回调函数出现在数组中，直到找到回调返回true的数组价值如果找到这样的元素，find将立即返回值该元素。否则，find返回undefined。回调是仅对已赋值的数组索引调用；它不会为已删除或从未删除的索引调用已分配值。

这是MDN文档。

查找功能是这样工作的。

function isPrime(element, index, array) {
    var start = 2;
    while (start <= Math.sqrt(element)) {
        if (element % start++ < 1) return false;
    }
    return (element > 1);
}

console.log( [4, 6, 8, 12].find(isPrime) ); // Undefined, not found
console.log( [4, 5, 8, 12].find(isPrime) ); // 5

通过定义函数，可以在ECMAScript 5及以下版本中使用此函数。

if (!Array.prototype.find) {
  Object.defineProperty(Array.prototype, 'find', {
    enumerable: false,
    configurable: true,
    writable: true,
    value: function(predicate) {
      if (this == null) {
        throw new TypeError('Array.prototype.find called on null or undefined');
      }
      if (typeof predicate !== 'function') {
        throw new TypeError('predicate must be a function');
      }
      var list = Object(this);
      var length = list.length >>> 0;
      var thisArg = arguments[1];
      var value;

      for (var i = 0; i < length; i++) {
        if (i in list) {
          value = list[i];
          if (predicate.call(thisArg, value, i, list)) {
            return value;
          }
        }
      }
      return undefined;
    }
  });
}

使用lodash的一些功能。

它简洁、准确，并且具有强大的跨平台支持。

接受的答案甚至不符合要求。

要求：推荐最简洁有效的方法来确定JavaScript数组是否包含对象。

接受答案：

$.inArray({'b': 2}, [{'a': 1}, {'b': 2}])
> -1

我的建议：

_.some([{'a': 1}, {'b': 2}], {'b': 2})
> true

笔记：

$.inArray可以很好地确定标量数组中是否存在标量值。。。

$.inArray(2, [1,2])
> 1

…但这个问题显然需要一种有效的方法来确定数组中是否包含对象。

为了处理标量和对象，可以执行以下操作：

(_.isObject(item)) ? _.some(ary, item) : (_.indexOf(ary, item) > -1)

如果你使用的是JavaScript 1.6或更高版本（Firefox 1.5或更高），你可以使用Array.indexOf。

只是另一种选择

// usage: if ( ['a','b','c','d'].contains('b') ) { ... }
Array.prototype.contains = function(value){
    for (var key in this)
        if (this[key] === value) return true;
    return false;
}

要小心，因为用自定义方法重载javascript数组对象会破坏其他java脚本的行为，从而导致意外行为。

希望更快的双向indexOf/lastIndexOf替代方案

2015

虽然新方法包含的内容非常好，但目前支持基本为零。

很长时间以来，我一直在想一种方法来替换缓慢的indexOf/lastIndexOf函数。

已经找到了一种表演方式，看看最热门的答案。我选择了@Damir Zekic发布的contains函数，这应该是最快的函数。但它也指出，基准是2008年的，因此已经过时。

我也更喜欢while而不是for，但不是出于特定原因，我用for循环结束了函数的编写。这也可以在一段时间内完成。

我很好奇，如果我在执行时检查数组的两侧，迭代是否会慢得多。显然没有，所以这个函数比排名靠前的函数快两倍左右。显然，它也比本地的更快。这是在一个真实的环境中，您永远不知道所搜索的值是在数组的开头还是结尾。

当你知道你只是用一个值推送一个数组时，使用lastIndexOf可能是最好的解决方案，但如果你必须遍历大数组，结果可能无处不在，这可能是一个让事情更快的可靠解决方案。

双向indexOf/lastIndexOf

function bidirectionalIndexOf(a, b, c, d, e){
  for(c=a.length,d=c*1; c--; ){
    if(a[c]==b) return c; //or this[c]===b
    if(a[e=d-1-c]==b) return e; //or a[e=d-1-c]===b
  }
  return -1
}

//Usage
bidirectionalIndexOf(array,'value');

性能测试

https://jsbench.me/7el1b8dj80

作为测试，我创建了一个包含100k个条目的数组。

三个查询：在数组的开头、中间和结尾。

我希望你也觉得这很有趣，并测试一下性能。

注意：正如您所看到的，我稍微修改了contains函数，以反映indexOf和lastIndexOf输出（因此，索引基本为true，-1为false）。这不应该伤害它。

阵列原型变体

Object.defineProperty(Array.prototype,'bidirectionalIndexOf',{value:function(b,c,d,e){
  for(c=this.length,d=c*1; c--; ){
    if(this[c]==b) return c; //or this[c]===b
    if(this[e=d-1-c] == b) return e; //or this[e=d-1-c]===b
  }
  return -1
},writable:false, enumerable:false});

// Usage
array.bidirectionalIndexOf('value');

该函数也可以很容易地修改为返回true或false，甚至返回对象、字符串或任何其他值。

下面是while变体：

function bidirectionalIndexOf(a, b, c, d){
  c=a.length; d=c-1;
  while(c--){
    if(b===a[c]) return c;
    if(b===a[d-c]) return d-c;
  }
  return c
}

// Usage
bidirectionalIndexOf(array,'value');

这怎么可能？

我认为，获取数组中反射索引的简单计算非常简单，比实际循环迭代快两倍。

这里有一个复杂的例子，每次迭代进行三次检查，但这仅在计算时间较长时才有可能，因为计算时间较长会导致代码速度减慢。

https://web.archive.org/web/20151019160219/http://jsperf.com/bidirectionalindexof/2

而array.indexOf（x）=-1是实现这一点的最简洁的方法（并且已经被非Internet Explorer浏览器支持了十多年……），它不是O（1），而是O（N），这很可怕。如果您的数组不会改变，您可以将数组转换为哈希表，然后执行表[x]==未定义或==未定义：

Array.prototype.toTable = function() {
    var t = {};
    this.forEach(function(x){t[x]=true});
    return t;
}

演示：

var toRemove = [2,4].toTable();
[1,2,3,4,5].filter(function(x){return toRemove[x]===undefined})

（不幸的是，虽然您可以创建Array.prototype.contains来“冻结”数组并将哈希表存储在this._cache中，但如果您选择稍后编辑数组，则会产生错误的结果。与Python不同，JavaScript没有足够的钩子来保持这种状态。）