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

Question

我有一个类似的数组

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

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

Answer 1

接受的答案仍然有效，但现在我们有一个 ECMAScript 6 原生方法 [Array.find][1] 和 [Array.some][2] 来实现相同的效果。

Array.some

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

引用 MDN：

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

Array.find

如果要从数组中获取匹配的对象，请使用 find 否则返回 undefined。

引用 MDN：

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

var arr = [];
var item1 = {
    id: 21,
    label: 'Banana',
};
var item2 = {
    id: 22,
    label: 'Apple',
};
arr.push(item1, item2);

/* note : data is the actual object that matched search criteria 
  or undefined if nothing matched */

var data = arr.find(function(ele) {
    return ele.id === 21;
});

if (data) {
    console.log('found');
    console.log(data); // This is entire object i.e. `item` not boolean
}


/* note : doesExist is a boolean thats true or false depending on of whether the data was found or not */
var doesExist = arr.some(function(ele) {
    return ele.id === 21;
});

见我的jsfiddle link IE 有一个polyfill provided by mozilla

Answer 2

2021 解决方案*

Lodash .some (docs) 是一个干净的解决方案，如果您使用 _matchesProperty (docs) 速记：

_.some(VENDORS, ['Name', 'Magenic'])

说明

这将遍历VENDORS 数组，以查找具有Name 键值的字符串'Magenic' 的元素对象。一旦找到这个元素，它就会返回true 并停止迭代。如果遍历整个 Array 后没有找到该元素，则返回 false。

代码 sn-p

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

console.log(_.some(VENDORS, ['Name', 'Magenic'])); // true

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.20/lodash.min.js"></script>

* 请注意，这使用流行的lodash 库来实现最简单/最短的解决方案。对于那些感兴趣的人，我将其作为现有 vanilla JS 解决方案的替代方案。

Answer 3

无需重新发明 wheel 循环，至少无需明确（使用arrow functions、modern browsers only）：

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

或者，更好，因为它允许浏览器在找到一个匹配的元素后立即停止，所以它会更快：

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 */
}

Answer 4

函数map、filter、find 和类似函数比简单循环慢得多。 对我来说，它们的可读性也比简单循环低，而且更难调试。使用它们看起来像是一种不合理的仪式。

最好有这样的东西：

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

并在给定的 OP 示例中像这样使用它：

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

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

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

Answer 5

我解决这个问题的方法是使用 ES6 并创建一个为我们进行检查的函数。此函数的好处是它可以在整个项目中重复使用，以检查给定 key 和 value 要检查的任何对象数组。

说够了，让我们看看代码

数组

const ceos = [
  {
    name: "Jeff Bezos",
    company: "Amazon"
  }, 
  {
    name: "Mark Zuckerberg",
    company: "Facebook"
  }, 
  {
    name: "Tim Cook",
    company: "Apple"
  }
];

功能

const arrayIncludesInObj = (arr, key, valueToCheck) => {
  return arr.some(value => value[key] === valueToCheck);
}

通话/使用

const found = arrayIncludesInObj(ceos, "name", "Tim Cook"); // true

const found = arrayIncludesInObj(ceos, "name", "Tim Bezos"); // false

Answer 6

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

console.log(check)

试试这个代码。

如果项目或元素存在，则输出将显示该元素。如果它不存在，则输出将为“未定义”。

Answer 7

如果我错了，请纠正我.. 我本可以像这样使用forEach 方法，

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

   }
});

现在我已经习惯了，因为它简单且不言自明。 谢谢。

Answer 8

可能为时已晚，但 javascript 数组有两个方法 some 和 every 方法返回一个布尔值，可以帮助您实现这一目标。

我认为some 最适合您想要实现的目标。

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

Some 验证数组中的任何对象是否满足给定条件。

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

Every 验证数组中的所有对象都满足给定条件。

Answer 9

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

Answer 10

正如 OP 提出的问题 密钥是否存在。

使用 ES6 reduce 函数返回布尔值的更优雅的解决方案可以是

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

注意：reduce的初始参数是false，如果数组有key则返回true。

希望它有助于更​​好、更简洁的代码实现

Answer 11

测试数组元素：

JS 提供数组函数，让您相对容易地实现这一点。它们是：

1. Array.prototype.filter: 接受一个回调函数，它是一个测试，然后用 is 回调迭代数组，并根据这个回调过滤。 返回一个新的过滤数组。
2. Array.prototype.some: 接受一个作为测试的回调函数，然后用 is callback 迭代数组，如果有任何元素通过测试， 返回布尔值 true。否则返回 false

具体细节最好通过一个例子来解释：

示例：

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

// filter returns a new array, we instantly check if the length 
// is longer than zero of this newly created array
if (vendors.filter(company => company.Name === 'Magenic').length ) {
  console.log('I contain Magenic');
}

// some would be a better option then filter since it directly returns a boolean
if (vendors.some(company => company.Name === 'Magenic')) {
  console.log('I also contain Magenic');
}

浏览器支持：

这两个函数是ES6 函数，并不是所有的浏览器都支持它们。为了克服这个问题，您可以使用 polyfill。这是 Array.prototype.some 的 polyfill（来自 MDN）：

if (!Array.prototype.some) {
  Array.prototype.some = function(fun, thisArg) {
    'use strict';

    if (this == null) {
      throw new TypeError('Array.prototype.some called on null or undefined');
    }

    if (typeof fun !== 'function') {
      throw new TypeError();
    }

    var t = Object(this);
    var len = t.length >>> 0;

    for (var i = 0; i < len; i++) {
      if (i in t && fun.call(thisArg, t[i], i, t)) {
        return true;
      }
    }

    return false;
  };
}

Answer 12

你可以试试它对我的工作。

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 } ]

Answer 13

为了比较一个对象和另一个对象，我结合了 for in 循环（用于循环对象）和 some()。 您不必担心数组超出范围等，这样可以节省一些代码。 .some 上的文档可以在here

找到

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

我比较一个对象和另一个对象的另一种方法是使用带有 Object.keys().length 的嵌套 for 循环来获取数组中对象的数量。代码如下：

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

要回答您的确切问题，如果只是在对象中搜索值，您可以使用单个 for in 循环。

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

Answer 14

2018 年编辑：这个答案来自 2011 年，当时浏览器还没有广泛支持数组过滤方法和箭头函数。看看CAFxX's answer。

没有“神奇”的方法可以在没有循环的情况下检查数组中的某些内容。即使您使用某些函数，该函数本身也会使用循环。您可以做的是在找到所需内容后立即跳出循环，以最大限度地减少计算时间。

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

Answer 15

这就是我的做法

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

array.some() 方法检查数组中是否至少有一个值符合条件并返回布尔值。 从这里开始，您可以使用：

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

Answer 16

这里的许多答案都很好而且很简单。但是，如果您的对象数组具有一组固定的值，那么您可以使用以下技巧：

映射对象中的所有名称。

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.
}

现在这个dirtyObj你可以一次又一次地使用而没有任何循环。

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

Answer 17

var without2 = (arr, args) => arr.filter(v => v.id !== args.id); 示例：

without2([{id:1},{id:1},{id:2}],{id:2})

结果： without2([{id:1},{id:1},{id:2}],{id:2})

Answer 18

您也可以这样做：

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

Answer 19

您可以使用 lodash。如果 lodash 库对您的应用程序来说太重，请考虑分块未使用的不必要函数。

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

希望我的回答有帮助。

Answer 20

根据 ECMAScript 6 规范，您可以使用 findIndex。

const magenicIndex = vendors.findIndex(vendor => vendor.Name === 'Magenic');

magenicIndex 将保存0（数组中的索引）或-1（如果未找到）。

Answer 21

不需要循环。想到的三种方法：

Array.prototype.some()

这是您问题的最准确答案，即“检查是否存在”，暗示布尔结果。如果有任何 'Magenic' 对象，则为 true，否则为 false：

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

Array.prototype.filter()

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

let magenicVendors = vendors.filter( vendor => vendor['Name'] === 'Magenic' )

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

Array.prototype.find()

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

let magenicVendor = vendors.find( vendor => vendor['Name'] === 'Magenic' );

这会强制转换为布尔值 OK（任何对象都是真实的，undefined 是虚假的）。

---

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

注意 2：检查名称时没有理由使用松散相等 (==) 而不是严格相等 (===)。

Answer 22

我宁愿使用正则表达式。

如果你的代码如下，

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

我会推荐

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

Answer 23

如果你使用 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);
}

Answer 24

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

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 这样的库来使这更令人愉悦：

Enumerable.From(vendors).Where("$.Name == 'Magenic'").First();

（请参阅jsFiddle 以获取演示）

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

Answer 25

你不能不仔细观察对象。

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

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

然后你可以像查找哈希一样使用它。

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

Answer 26

除非你想像这样重组它：

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

你可以做if(vendors.Magnetic)

你必须循环