如何确定Javascript数组是否包含属性等于给定值的对象？

我有一个类似的数组

vendors = [{
    Name: 'Magenic',
    ID: 'ABC'
  },
  {
    Name: 'Microsoft',
    ID: 'DEF'
  } // and so on... 
];

---

如何检查此阵列以查看是否存在“Magenic”？我不想循环，除非我必须循环。我正在处理可能有几千条记录。

除非您想像这样重新构造它：

vendors = {
    Magenic: {
      Name: 'Magenic',
      ID: 'ABC'
     },
    Microsoft: {
      Name: 'Microsoft',
      ID: 'DEF'
    } and so on... 
};

 arrayHelper = {
     arrayContainsObject: function (array, object, key){
         for (let i = 0; i < array.length; i++){
            if (object[key] === array[i][key]){
                 return true;
            }
         }
         return false;
     }
     
   };

如果（vendors.Magnetic）

---

您将不得不循环编辑：这个答案来自2011年，那时浏览器还没有广泛支持数组过滤方法和箭头功能。看一看

没有“神奇”的方法可以在没有循环的数组中检查某些内容。即使使用某个函数，函数本身也将使用循环。你能做的就是在你找到你要找的东西后立即跳出循环，以最小化计算时间

var found = false;
for(var i = 0; i < vendors.length; i++) {
    if (vendors[i].Name == 'Magenic') {
        found = true;
        break;
    }
}

var-found=false；
对于（var i=0；i

如果不仔细观察对象，你就不能这样做

你可能应该改变一下你的结构，比如

vendors = {
    Magenic:   'ABC',
    Microsoft: 'DEF'
};

然后，您可以像查找散列一样使用它

vendors['Microsoft']; // 'DEF'
vendors['Apple']; // undefined

---

你必须循环，没有办法绕过它

function seekVendor(vendors, name) {
  for (var i=0, l=vendors.length; i<l; i++) {
    if (typeof vendors[i] == "object" && vendors[i].Name === name) {
      return vendors[i];
    }
  }
}

（请参见演示）

我怀疑linq.js会比直接循环快，但当事情变得更复杂时，它肯定会更灵活。

无需重新设计轮子循环，至少不需要明确地（使用，）：

或者，更好一些：

if (vendors.some(e => e.Name === 'Magenic')) {
  /* vendors contains the element we're looking for */
}

编辑：如果您需要与糟糕的浏览器兼容，那么最好的选择是：

if (vendors.filter(function(e) { return e.Name === 'Magenic'; }).length > 0) {
  /* vendors contains the element we're looking for */
}

---

如果使用jquery，可以利用grep创建包含所有匹配对象的数组：

var results = $.grep(vendors, function (e) {
    return e.Name == "Magenic";
});

然后使用结果数组：

for (var i=0, l=results.length; i<l; i++) {
    console.log(results[i].ID);
}

---

for（var i=0，l=results.length；i公认的答案仍然有效，但现在我们有了一个ECMAScript 6本机方法
[Array.find][1]
和
[Array.some][2]
，以达到同样的效果

数组。一些

如果您只想确定某个元素是否存在，即需要确定
true/false，请使用
some

引用MDN：

some（）方法测试数组中是否至少有一个元素通过了所提供函数实现的测试。如果在数组中找到了所提供函数返回true的元素，则返回true；否则返回false。它不会修改数组

数组。查找

如果要从数组中获取匹配的对象，请使用“查找”，否则将返回未定义的

引用MDN：

find（）方法返回所提供数组中满足所提供测试函数的第一个元素的值。如果没有值满足测试函数，则返回undefined

var arr=[]；
变量项1={
id:21，
标签：“香蕉”，
};
变量项2={
身份证号码：22，
标签：“苹果”，
};
arr.push（第1项、第2项）；
/*注意：数据是符合搜索条件的实际对象
如果没有匹配项，则为未定义*/
var数据=arr.find（函数（ele）{
返回ele.id=='21'；
});
如果（数据）{
console.log（'found'）；
console.log（data）；//这是整个对象，即`item`不是布尔值
}
/*注意：doesExist是一个布尔值，根据是否找到数据而定*/
var doesExist=arr.some（函数（ele）{
返回ele.id=='21'；
});

看我的，IE有一个polyfill，我宁愿使用regex

如果您的代码如下所示

vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    }
];

我推荐

/"Name":"Magenic"/.test(JSON.stringify(vendors))

无需循环。想到三种方法：

Array.prototype.some（）

这是您问题的最准确答案，即“检查某物是否存在”，意味着bool结果。如果存在任何“Magenic”对象，则为真，否则为假：

let hasMagenicVendor = vendors.some( vendor => vendor['Name'] === 'Magenic' )

Array.prototype.filter（）

这将返回所有“Magenic”对象的数组，即使只有一个（将返回一个元素数组）：

如果您试图将其强制为布尔值，它将不起作用，因为空数组（没有“Magenic”对象）仍然是真实的。因此只需在条件中使用
magenicVendors.length

Array.prototype.find（）

这将返回第一个“Magenic”对象（或
未定义的对象，如果没有）：

这强制为布尔OK（任何对象都是真实的，
未定义的
都是虚假的）


注意：我使用vendor[“Name”]而不是vendor.Name，因为属性名的大小写很奇怪

注2：检查名称时，没有理由使用松散相等（==）而不是严格相等（==）。
根据ECMAScript 6规范，您可以使用

const-magenicIndex=vendors.findIndex（vendor=>vendor.Name=='Magenic'）；

magenicIndex
将保留
0
（数组中的索引）或
-1
（如果找不到该索引）。
如果我错了，请更正我。。
我本可以用这样的
forEach
方法

var found=false;
vendors.forEach(function(item){
   if(item.name === "name"){
       found=true;

   }
});

现在我已经习惯了，因为它简单易懂。
谢谢。
 可以使用<强> Loase。如果应用程序库太重，请考虑不使用不必要的功能。

let newArray = filter(_this.props.ArrayOne, function(item) {
                    return find(_this.props.ArrayTwo, {"speciesId": item.speciesId});
                });

这只是一种方法。另一种方法可以是：

var newArray=  [];
     _.filter(ArrayOne, function(item) {
                        return AllSpecies.forEach(function(cItem){
                            if (cItem.speciesId == item.speciesId){
                            newArray.push(item);
                          }
                        }) 
                    });

console.log（arr）；

也可以重写上述示例，而无需使用任何库，如：

var newArray=  [];
ArrayOne.filter(function(item) {
                return ArrayTwo.forEach(function(cItem){
                    if (cItem.speciesId == item.speciesId){
                    newArray.push(item);
                  }
                }) 
            });
console.log(arr);

希望我的回答有帮助。
或者您可以：

const find = (key, needle) => return !!~vendors.findIndex(v => (v[key] === needle));

var without2=（arr，args）=>arr.filter（v=>v.id！==args.id）；

例如：

without2（[{id:1}，{id:1}，{id:2}]，{id:2}）

结果:
没有2（[{id:1}，{id:1}，{id:2}]，{id:2}）
这里的许多答案都很好而且非常简单。但是如果对象数组有一组固定的值，那么您可以使用以下技巧：

映射对象中的所有名称

vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    }
];

var dirtyObj = {}
for(var count=0;count<vendors.length;count++){
   dirtyObj[vendors[count].Name] = true //or assign which gives you true.
}

正如OP提出的问题是否存在密钥o
var newArray=  [];
ArrayOne.filter(function(item) {
                return ArrayTwo.forEach(function(cItem){
                    if (cItem.speciesId == item.speciesId){
                    newArray.push(item);
                  }
                }) 
            });
console.log(arr);

const find = (key, needle) => return !!~vendors.findIndex(v => (v[key] === needle));

vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    }
];

var dirtyObj = {}
for(var count=0;count<vendors.length;count++){
   dirtyObj[vendors[count].Name] = true //or assign which gives you true.
}

if(dirtyObj[vendor.Name]){
  console.log("Hey! I am available.");
}

const magenicVendorExists =  vendors.reduce((accumulator, vendor) => (accumulator||vendor.Name === "Magenic"), false);

const found = vendors.some(item => item.Name === 'Magenic');

if (found) {
// do something
} else {
// do something else
}

var productList = [{id: 'text3'}, {id: 'text2'}, {id: 'text4', product: 'Shampoo'}]; // Example of selected products
var theDatabaseList = [{id: 'text1'}, {id: 'text2'},{id: 'text3'},{id:'text4', product: 'shampoo'}];    
var  objectsFound = [];

for(let objectNumber in productList){
    var currentId = productList[objectNumber].id;   
    if (theDatabaseList.some(obj => obj.id === currentId)) {
        // Do what you need to do with the matching value here
        objectsFound.push(currentId);
    }
}
console.log(objectsFound);

var productList = [{id: 'text3'}, {id: 'text2'}, {id: 'text4', product: 'Shampoo'}]; // Example of selected products
var theDatabaseList = [{id: 'text1'}, {id: 'text2'},{id: 'text3'},{id:'text4', product: 'shampoo'}];    
var objectsFound = [];

for(var i = 0; i < Object.keys(productList).length; i++){
        for(var j = 0; j < Object.keys(theDatabaseList).length; j++){
        if(productList[i].id === theDatabaseList[j].id){
            objectsFound.push(productList[i].id);
        }       
    }
}
console.log(objectsFound);

var vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    } 
];

for(var ojectNumbers in vendors){
    if(vendors[ojectNumbers].Name === 'Magenic'){
        console.log('object contains Magenic');
    }
}

const _ = require('lodash');

var arr = [
  {
    name: 'Jack',
    id: 1
  },
  {
    name: 'Gabriel',
    id: 2
  },
  {
    name: 'John',
    id: 3
  }
]

function findValue(arr,value) {
  return _.filter(arr, function (object) {
    return object['name'].toLowerCase().indexOf(value.toLowerCase()) >= 0;
  });
}

console.log(findValue(arr,'jack'))
//[ { name: 'Jack', id: 1 } ]

vendors.some( vendor => vendor['Name'] !== 'Magenic' )

vendors.every( vendor => vendor['Name'] !== 'Magenic' )

const a = [{one:2},{two:2},{two:4}]
const b = a.filter(val => "two" in val).length;
if (b) {
   ...
}

const check = vendors.find((item)=>item.Name==='Magenic')

console.log(check)

 arrayHelper = {
     arrayContainsObject: function (array, object, key){
         for (let i = 0; i < array.length; i++){
            if (object[key] === array[i][key]){
                 return true;
            }
         }
         return false;
     }
     
   };

    vendors = [{
    Name: 'Magenic',
    ID: 'ABC'
     },
     {
    Name: 'Microsoft',
    ID: 'DEF'
     } 
  ];

let abcObject = {ID: 'ABC', Name: 'Magenic'};

let isContainObject = arrayHelper.arrayContainsObject(vendors, abcObject, 'ID');