ECMAScript 7引入了Array.prototype.includes。

它可以这样使用：

[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false

它还接受来自Index的可选第二个参数：

[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true

与使用严格相等比较的indexOf不同，indexOf包括使用SameValueZero相等算法的比较。这意味着您可以检测阵列是否包含NaN：

[1, 2, NaN].includes(NaN); // true

与indexOf不同，includes不会跳过缺少的索引：

new Array(5).includes(undefined); // true

它可以是多填充的，以使其在所有浏览器上都可以使用。

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

ECMAScript 7引入了Array.prototype.includes。

它可以这样使用：

[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false

它还接受来自Index的可选第二个参数：

[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true

与使用严格相等比较的indexOf不同，indexOf包括使用SameValueZero相等算法的比较。这意味着您可以检测阵列是否包含NaN：

[1, 2, NaN].includes(NaN); // true

与indexOf不同，includes不会跳过缺少的索引：

new Array(5).includes(undefined); // true

它可以是多填充的，以使其在所有浏览器上都可以使用。

如果您正在重复检查数组中是否存在对象，您可能应该查看

通过在数组中执行插入排序（将新对象放在正确的位置），始终保持数组排序将更新对象设置为删除+排序插入操作和在contains（a，obj）中使用二进制搜索查找。

我们使用以下代码段（用于对象、数组和字符串）：

/*
 * @function
 * @name Object.prototype.inArray
 * @description Extend Object prototype within inArray function
 *
 * @param {mix}    needle       - Search-able needle
 * @param {bool}   searchInKey  - Search needle in keys?
 *
 */
Object.defineProperty(Object.prototype, 'inArray',{
    value: function(needle, searchInKey){

        var object = this;

        if( Object.prototype.toString.call(needle) === '[object Object]' || 
            Object.prototype.toString.call(needle) === '[object Array]'){
            needle = JSON.stringify(needle);
        }

        return Object.keys(object).some(function(key){

            var value = object[key];

            if( Object.prototype.toString.call(value) === '[object Object]' || 
                Object.prototype.toString.call(value) === '[object Array]'){
                value = JSON.stringify(value);
            }

            if(searchInKey){
                if(value === needle || key === needle){
                return true;
                }
            }else{
                if(value === needle){
                    return true;
                }
            }
        });
    },
    writable: true,
    configurable: true,
    enumerable: false
});

用法：

var a = {one: "first", two: "second", foo: {three: "third"}};
a.inArray("first");          //true
a.inArray("foo");            //false
a.inArray("foo", true);      //true - search by keys
a.inArray({three: "third"}); //true

var b = ["one", "two", "three", "four", {foo: 'val'}];
b.inArray("one");         //true
b.inArray('foo');         //false
b.inArray({foo: 'val'})   //true
b.inArray("{foo: 'val'}") //false

var c = "String";
c.inArray("S");        //true
c.inArray("s");        //false
c.inArray("2", true);  //true
c.inArray("20", true); //false

我查看了提交的答案，发现只有通过引用搜索对象时，这些答案才适用。具有参考对象比较的简单线性搜索。

但是，假设您没有对象的引用，如何在数组中找到正确的对象？您必须对每个对象进行线性和深度比较。想象一下，如果列表太大，并且其中的对象非常大，包含大量文本。随着阵列中元素的数量和大小，性能急剧下降。

您可以将对象字符串化并将其放入本机哈希表中，但这样您就有了记住这些键的数据冗余，因为JavaScript将它们保存为“for i in obj”，您只需要检查对象是否存在，也就是说，您拥有该键。

我考虑了一段时间来构建一个JSON模式验证器，我为本地哈希表设计了一个简单的包装器，类似于唯一的哈希表实现，但一些优化异常我留给本地哈希表处理。它只需要性能基准。。。所有详细信息和代码都可以在我的博客上找到：http://stamat.wordpress.com/javascript-quickly-find-very-large-objects-in-a-large-array/我将很快发布基准结果。

完整的解决方案如下所示：

var a = {'a':1,
 'b':{'c':[1,2,[3,45],4,5],
 'd':{'q':1, 'b':{'q':1, 'b':8},'c':4},
 'u':'lol'},
 'e':2};

 var b = {'a':1, 
 'b':{'c':[2,3,[1]],
 'd':{'q':3,'b':{'b':3}}},
 'e':2};

 var c = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.";

 var hc = new HashCache([{a:3, b:2, c:5}, {a:15, b:2, c:'foo'}]); //init

 hc.put({a:1, b:1});
 hc.put({b:1, a:1});
 hc.put(true);
 hc.put('true');
 hc.put(a);
 hc.put(c);
 hc.put(d);
 console.log(hc.exists('true'));
 console.log(hc.exists(a));
 console.log(hc.exists(c));
 console.log(hc.exists({b:1, a:1}));
 hc.remove(a);
 console.log(hc.exists(c));