在所有现代浏览器中都可用的解决方案：

function contains(arr, obj) {
  const stringifiedObj = JSON.stringify(obj); // Cache our object to not call `JSON.stringify` on every iteration
  return arr.some(item => JSON.stringify(item) === stringifiedObj);
}

使用方法：

contains([{a: 1}, {a: 2}], {a: 1}); // true

IE6+ 解决方案：

function contains(arr, obj) {
  var stringifiedObj = JSON.stringify(obj)
  return arr.some(function (item) {
    return JSON.stringify(item) === stringifiedObj;
  });
}

// .some polyfill, not needed for IE9+
if (!('some' in Array.prototype)) {
  Array.prototype.some = function (tester, that /*opt*/) {
    for (var i = 0, n = this.length; i < n; i++) {
      if (i in this && tester.call(that, this[i], i, this)) return true;
    } return false;
  };
}

使用方法：

contains([{a: 1}, {a: 2}], {a: 1}); // true

为什么要使用JSON.stringify？

Array.indexOf和Array.includes(以及这里的大多数答案)只比较引用而不是值。

[{a: 1}, {a: 2}].includes({a: 1});
// false, because {a: 1} is a new object

奖金

未经优化的ES6单行代码：

[{a: 1}, {a: 2}].some(item => JSON.stringify(item) === JSON.stringify({a: 1));
// true

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

实现这个要求的简单方法是使用find()

如果你有以下形式的对象数组：

var users = [{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "admin"},
{id: "105", name: "user"}];

然后您可以检查对象中是否已经存在具有您的值的对象：

let data = users.find(object => object['id'] === '104');

如果数据为空，则没有管理员，否则它将返回现有的对象，例如：

{id: "104", name: "admin"}

然后，您可以通过以下代码在数组中找到该对象的索引并替换对象：

let indexToUpdate = users.indexOf(data);
let newObject = {id: "104", name: "customer"};
users[indexToUpdate] = newObject;//your new object
console.log(users);

您将获得像这样的值：

[{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "customer"},
{id: "105", name: "user"}];

虽然 array.indexOf(x)!=-1 是最简洁的方法（并且非IE浏览器支持这种方法已经十多年了...），但它不是O(1)，而是O(N)，这非常糟糕。如果您的数组不会改变，您可以将数组转换为哈希表，然后执行table[x]!==undefined或===undefined：

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缺乏让您保持此状态的钩子。

ECMAScript 6 在 find 上有一个优雅的提案。

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

这是MDN文档。

find 功能的工作方式如下。

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

可以使用具有"has()"方法的Set：

function contains(arr, obj) {
      var proxy = new Set(arr);
      if (proxy.has(obj))
        return true;
      else
        return false;
    }

    var arr = ['Happy', 'New', 'Year'];
    console.log(contains(arr, 'Happy'));

使用：

var myArray = ['yellow', 'orange', 'red'] ;

alert(!!~myArray.indexOf('red')); //true

演示

要了解在此处 tilde ~ 的确切作用，请参阅这个问题：当波浪号在表达式之前时，波浪号有什么作用？。

好的，你只需要优化你的代码就可以得到结果！

有很多方法可以做到更加清晰和更好的优化，但我只是想获取你的模式并使用 JSON.stringify 应用它，只需在你的情况下简单地执行以下操作：

function contains(a, obj) {
    for (var i = 0; i < a.length; i++) {
        if (JSON.stringify(a[i]) === JSON.stringify(obj)) {
            return true;
        }
    }
    return false;
}

惊讶的是这个问题仍然没有最新的语法，我来贡献我的看法。

假设我们有一个对象数组 arrObj ，我们想在其中搜索 obj .

Array.prototype.indexOf ->（返回 索引或 -1）通常用于查找数组中元素的索引。如果您传递对相同对象的引用，则也可以用于搜索对象。

let obj = { name: 'Sumer', age: 36 };
let arrObj = [obj, { name: 'Kishor', age: 46 }, { name: 'Rupen', age: 26 }];


console.log(arrObj.indexOf(obj));// 0
console.log(arrObj.indexOf({ name: 'Sumer', age: 36 })); //-1

console.log([1, 3, 5, 2].indexOf(2)); //3

Array.prototype.includes -> (返回 true 或 false)

console.log(arrObj.includes(obj));  //true
console.log(arrObj.includes({ name: 'Sumer', age: 36 })); //false

console.log([1, 3, 5, 2].includes(2)); //true

Array.prototype.find -> (使用回调函数，返回第一个在回调函数中返回true的值/对象)。

console.log(arrObj.find(e => e.age > 40));  //{ name: 'Kishor', age: 46 }
console.log(arrObj.find(e => e.age > 40)); //{ name: 'Kishor', age: 46 }

console.log([1, 3, 5, 2].find(e => e > 2)); //3

Array.prototype.findIndex -> （接受回调函数，返回第一个返回true的值或对象的索引）。

console.log(arrObj.findIndex(e => e.age > 40));  //1
console.log(arrObj.findIndex(e => e.age > 40)); //1

console.log([1, 3, 5, 2].findIndex(e => e > 2)); //1

由于find和findIndex接受回调函数，我们可以通过创造性地设置true条件，从数组中获取任何对象（即使我们没有引用）。