Javascript 如何确定对象是否在数组中

我需要确定javascript中的数组中是否已经存在对象

例如（dummycode）：

现在，“carBrands”数组包含所有实例。 我现在正在寻找一个快速解决方案，以检查carBrands阵列中是否已经存在car1、car2、car3或car4的实例

例如：

---

var contains=carBrands.contains（car1）// 使用类似以下内容：

function containsObject(obj, list) {
    var i;
    for (i = 0; i < list.length; i++) {
        if (list[i] === obj) {
            return true;
        }
    }

    return false;
}

这种方法也适用于阵列，但在阵列上使用时，会比第一个选项慢一点。
您可以使用相等运算符：
==
。默认情况下，对象通过引用进行检查，因此您甚至不需要使用
=
操作符

尝试此操作，只需确保在
car1
位置使用了正确的变量引用：

var i, car, l = cars.length;

for (i = 0; i < l; i++)
{
  if ((car = cars[i]) == car1)
  {
    break;
  }
  else car = null;
}

var i，car，l=cars.length；
对于（i=0；i

编辑以添加：

提到了一个数组扩展，下面是它的代码：

Array.prototype.contains = Array.prototype.contains || function(obj)
{
  var i, l = this.length;
  for (i = 0; i < l; i++)
  {
    if (this[i] == obj) return true;
  }
  return false;
};

Array.prototype.contains=Array.prototype.contains | |函数（obj）
{
var i，l=该长度；
对于（i=0；i

请注意，我正在缓存长度值，因为数组的
length
属性实际上是一个访问器，它比内部变量稍微慢一些。
您可以使用以下方法：

但是，由于没有指定jQuery，所以可以对函数进行派生。从源代码：

function grepArray( elems, callback, inv ) {  
    var ret = [];  

    // Go through the array, only saving the items  
    // that pass the validator function  
    for ( var i = 0, length = elems.length; i < length; i++ ) {  
        if ( !inv !== !callback( elems[ i ], i ) ) {  
            ret.push( elems[ i ] );  
        }  
    }  

    return ret;  
}  

grepArray(carBrands, function(obj) { return obj.name == "ford"; });

函数grepArray（元素、回调、inv）{
var-ret=[]；
//遍历数组，只保存项目
//通过验证器函数的
对于（var i=0，length=elems.length；i
您可以尝试根据属性对数组进行排序，如下所示：

carBrands = carBrands.sort(function(x,y){
  return (x == y) ? 0 : (x > y) ? 1 : -1;
});

然后可以使用迭代例程检查

carBrands[Math.floor(carBrands.length/2)] 
// change carBrands.length to a var that keeps 
// getting divided by 2 until result is the target 
// or no valid target exists

大于或小于目标，依此类推，这将让您快速遍历数组以查找对象是否存在。
我使用
下划线
javascript库来调整此问题

function containsObject(obj, list) {
 var res = _.find(list, function(val){ return _.isEqual(obj, val)});
 return (_.isObject(res))? true:false;
}

有关上述示例中使用的下划线函数，请参阅文档

注意：这不是一个纯javascript解决方案。出于教育目的共享。
为什么不使用javascript数组的indexOf方法

看看这个：

简单地做：

carBrands.indexOf(car1);

它将返回car1的索引（数组中的位置）。如果在数组中找不到car1，它将返回-1


编辑：注意，在问题中，要求检查数组中引用的相同对象，而不是新对象。即使新对象的内容与数组中的对象相同，它仍然是不同的对象。
如注释中所述，对象在JS中通过引用传递，同一对象可以在多个结构中多次存在。

如果要创建一个新对象并检查数组中是否包含与新对象相同的对象，则此答案无效（下面是Julien的小提琴），如果要检查数组中是否存在相同的对象，则此答案有效。查看这里的fiddle和评论。
我知道这是一篇老文章，但我想提供JQuery插件版本和我的代码

// Find the first occurrence of object in list, Similar to $.grep, but stops searching 
function findFirst(a,b){
var i; for (i = 0; i < a.length; ++i) { if (b(a[i], i)) return a[i]; } return undefined;
}

我将在数组上使用属性/值的通用迭代器。不需要jQuery

arr = [{prop1: 'val1', prop2: 'val2'}, {prop1: 'val3', prop2: 'val4'}];

objectPropInArray(arr, 'prop1', 'val3'); // <-- returns true

function objectPropInArray(list, prop, val) {
  if (list.length > 0 ) {
    for (i in list) {
      if (list[i][prop] === val) {
        return true;
      }
    }
  }
  return false;  
}

arr=[{prop1:'val1'，prop2:'val2'}，{prop1:'val3'，prop2:'val4'}]；
objectPropInArray（arr，'prop1'，'val3'）；//0 ) {
对于（列表中的i）{
如果（列表[i][prop]==val）{
返回true；
}
}
}
返回false；
}
此功能用于检查唯一字段。
Arg 1:包含选定数据的数组
Arg 2：要检查的密钥
Arg 3:必须“验证”的值

最近被FP bug咬了一口，读到了许多关于函数范式如何与Javascript完美结合的精彩报道

为了完整性起见，我复制了代码，并建议在功能上有两种方法

    var carBrands = [];

  var car1 = {name:'ford'};
  var car2 = {name:'lexus'};
  var car3 = {name:'maserati'};
  var car4 = {name:'ford'};
  var car5 = {name:'toyota'};

  carBrands.push(car1);
  carBrands.push(car2);
  carBrands.push(car3);
  carBrands.push(car4);

  // ES6 approach which uses the includes method (Chrome47+, Firefox43+)

  carBrands.includes(car1) // -> true
  carBrands.includes(car5) // -> false

如果需要支持较旧的浏览器，请使用polyfill，IE9+和Edge似乎不支持它。位于

或者，我想提出一个更新的答案

试试Array.prototype.some（）


您是要根据字典进行检查，还是要使用名称进行测试？您可以对
carBrands
使用哈希，然后只测试所需的键。您可以使用方法some:let contains=carsBrands.some（car=>car.name==car1.name）此问题与重复问题不同，因为它处理的是对象而不是原语。使用简单的
===
仅在对数组中的对象具有精确引用的最简单情况下有效。+1。我的回答没有抓住要点。这是对的。（作为旁注，您可以像OP扩展Array.prototype那样做）应该在i或x之前添加一个var，例如：for（列表中的var x）@RobB Yeah，看起来我犯了一个复制粘贴错误--
var i
应该是
var x
。修正了，谢谢你指出。应该是JSON.stringify（list[i]）==JSON.stringify（obj）而不是list[i]==obj@MartínNieva可能是因为您要查找的对象不在列表中，而是一个不同的对象，比较起来非常相等。在这种情况下，使用lodash比滥用序列化更好。（事实上，使用lodash，整个解决方案变成了一个单行程序，结合了
.some
和
.isEqual
：
.some（list，v=>.isEqual（v，o））
）。更快地向后循环一段时间<代码>变量i=此长度；而（i-）{…}自
carBrands.indexOf(car1);

// Find the first occurrence of object in list, Similar to $.grep, but stops searching 
function findFirst(a,b){
var i; for (i = 0; i < a.length; ++i) { if (b(a[i], i)) return a[i]; } return undefined;
}

var product = $.findFirst(arrProducts, function(p) { return p.id == 10 });

arr = [{prop1: 'val1', prop2: 'val2'}, {prop1: 'val3', prop2: 'val4'}];

objectPropInArray(arr, 'prop1', 'val3'); // <-- returns true

function objectPropInArray(list, prop, val) {
  if (list.length > 0 ) {
    for (i in list) {
      if (list[i][prop] === val) {
        return true;
      }
    }
  }
  return false;  
}

function objectUnique( array, field, value )
{
    var unique = true;
    array.forEach(function ( entry )
    {
        if ( entry[field] == value )
        {
            unique = false;
        }
    });

    return unique;
}

    var carBrands = [];

  var car1 = {name:'ford'};
  var car2 = {name:'lexus'};
  var car3 = {name:'maserati'};
  var car4 = {name:'ford'};
  var car5 = {name:'toyota'};

  carBrands.push(car1);
  carBrands.push(car2);
  carBrands.push(car3);
  carBrands.push(car4);

  // ES6 approach which uses the includes method (Chrome47+, Firefox43+)

  carBrands.includes(car1) // -> true
  carBrands.includes(car5) // -> false

// ES2015 syntax
function containsObject(obj, list) {

    return list.some(function(elem) {
      return elem === obj
    })
}

// or ES6+ syntax with cool fat arrows
function containsObject(obj, list) {

    return list.some(elem => elem === obj)
}


    function isBiggerThan10(element, index, array) {
      return element > 10;
    }
    [2, 5, 8, 1, 4].some(isBiggerThan10);  // false
    [12, 5, 8, 1, 4].some(isBiggerThan10); // true