Как определить, содержит ли массив Javascript объект с атрибутом, равным заданному значению?

У меня есть массив как

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

Как проверить этот массив, чтобы увидеть, существует ли Magenic? Я не хочу зацикливаться, если я не должен. Я работаю с потенциально несколькими тысячами записей.

ОБНОВЛЕНО

Поскольку это был популярный пост, я решил поделиться чем-то новым, что нашел. И, кажется, @CAFxX уже поделился этим! Я должен читать это чаще. Я наткнулся на https://benfrain.com/understanding-native-javascript-array-methods/ .

vendors.filter(function(vendor){ return vendor.Name === "Magenic" })

А с ECMAScript 2015 стало еще проще использовать новые функции стрелок:

vendors.filter(vendor => vendor.Name === "Magenic")

Редактирование 2018 года : этот ответ с 2011 года, до того, как браузеры широко поддерживали методы фильтрации массивов и функции стрелок. Посмотрите на ответ CAFxX .

Не существует «волшебного» способа проверить что-либо в массиве без цикла. Даже если вы используете какую-то функцию, сама функция будет использовать цикл. Что вы можете сделать, так это выйти из цикла, как только вы найдете то, что ищете, чтобы минимизировать время вычислений.

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

Не нужно изобретать рулевое колесоцикл, по крайней мере, явно (с использованием функций стрелок , только в современных браузерах ):

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

Нет необходимости петли. Три метода, которые приходят на ум:

Array.prototype.some ()

Это самый точный ответ на ваш вопрос, то есть «проверьте, если что-то существует», что подразумевает результат bool. Это будет верно, если есть какие-либо «магические» объекты, иначе ложь:

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

Это приводит к булеву окей (любой объект правдив, undefinedфальшив).

Примечание: я использую vendor ["Name"] вместо vendor.Name из-за странного расположения имен свойств.

Примечание 2: Нет причин использовать свободное равенство (==) вместо строгого равенства (===) при проверке имени.

Принятый ответ все еще работает, но теперь у нас есть собственный метод ECMAScript 6 [Array.find][1] для достижения того же эффекта.

Цитируя MDN:

Метод find () возвращает значение первого элемента в массиве, который удовлетворяет предоставленной функции тестирования. В противном случае возвращается undefined.

var arr = []; 
var item = {
  id: '21',
  step: 'step2',
  label: 'Banana',
  price: '19$'
};

arr.push(item);
/* 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
}

Смотрите мою ссылку на jsfiddle. Существует полифил для IE, предоставляемый mozilla.

Вот как я это сделаю

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

array.some()Метод проверяет, есть ли хотя бы одно значение в массиве, которое соответствует критериям, и возвращает логическое значение. С этого момента вы можете пойти с:

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

Если вы не хотите реструктурировать это так:

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

на что ты можешь if(vendors.Magnetic)

Вам придется зациклить

Согласно спецификации ECMAScript 6, вы можете использовать findIndex.

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

magenicIndexбудет содержать 0( или это индекс в массиве), или -1если он не был найден.

Как ОП задал вопрос, существует ли ключ или нет .

Более элегантное решение, которое будет возвращать логическое значение с использованием функции сокращения ES6, может быть

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

Примечание . Начальным параметром Reduce является a, falseи если массив имеет ключ, он вернет true.

Надеюсь, это поможет для лучшей и чистой реализации кода

Вы не можете, не глядя на объект на самом деле.

Вы, вероятно, должны немного изменить свою структуру, как

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

Тогда вы можете просто использовать его как хеш поиска.

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

Может быть слишком поздно, но массив JavaScript имеет два метода someиevery метод, который возвращает логическое значение и может помочь вам достичь этого.

Я думаю, someчто будет наиболее подходящим для того, что вы намерены достичь.

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

Некоторые подтверждают, что любой из объектов в массиве удовлетворяет заданному условию.

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

Каждый проверяет, что все объекты в массиве удовлетворяют заданному условию.

Вы должны зацикливаться, нет никакого способа обойти это.

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 будет быстрее, чем прямой цикл, но он, безусловно, будет более гибким, когда все немного сложнее.

Тестирование для элементов массива:

JS предлагает функции массива, которые позволяют вам достичь этого относительно легко. Они следующие:

1. Array.prototype.filter: Принимает функцию обратного вызова, которая является тестом, затем массив перебирается с обратным вызовом и фильтруется в соответствии с этим обратным вызовом. Новый отфильтрованный массив возвращается.
2. Array.prototype.some: Принимает функцию обратного вызова, которая является тестом, затем массив перебирается с помощью функции обратного вызова, и если какой-либо элемент проходит тест, возвращается логическое значение 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');
}

Поддержка браузера:

Эти 2 функции являются ES6функциональными, не все браузеры могут их поддерживать. Чтобы преодолеть это, вы можете использовать полифилл. Вот полифилл для Array.prototype.some(из 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;
  };
}

если вы используете 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);
}

Поправьте меня, если я ошибаюсь ... я мог бы использовать forEachтакой метод,

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

   }
});

В настоящее время я привык к этому, из-за его простоты и понятного слова. Спасибо.

Вы можете попробовать это для меня.

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

Вы можете использовать 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);

Надеюсь, мой ответ поможет.

Многие ответы здесь хороши и довольно просты. Но если ваш массив объектов имеет фиксированный набор значений, вы можете использовать следующий трюк:

Сопоставьте все имя в объекте.

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

Чтобы сравнить один объект с другим, я объединяю цикл for (используется для циклического перемещения по объектам) и some (). Вам не нужно беспокоиться о выходе массива за пределы границ и т. Д., Чтобы сохранить некоторый код. Документацию по .some можно найти здесь

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

Альтернативный способ сравнения одного объекта с другим - использовать вложенный цикл for с Object.keys (). Length, чтобы получить количество объектов в массиве. Код ниже:

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.

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

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

Мой подход к решению этой проблемы заключается в использовании 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) => {
  let found = false;

  arr.some(value => {
    if (value[key] === valueToCheck) {
      found = true;
      return true; // this will break the loop once found
    }
  });

  return found;
}

Вызов / Usage

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

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

Я предпочел бы пойти с регулярным выражением.

Если ваш код выглядит следующим образом,

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

я бы порекомендовал

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