Javascript 배열에 주어진 값과 동일한 속성을 가진 객체가 포함되어 있는지 확인하는 방법은 무엇입니까?

나는 같은 배열을 가지고있다.

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

Magenic이 존재하는지 확인하려면이 배열을 어떻게 확인합니까? 내가하지 않으면 루프를하고 싶지 않습니다. 잠재적으로 2 천 개의 레코드로 작업하고 있습니다.

업데이트

이것은 인기있는 게시물이기 때문에 내가 찾은 새로운 것을 나눌 것이라고 생각했습니다. @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 ()

이것은 귀하의 질문에 대한 가장 정확한 답변입니다. 즉, "뭔가 있는지 확인하십시오"는 잘못된 결과를 암시합니다. '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' );

이것은 부울 괜찮아로 강제합니다 (모든 물건이 진실하고 undefined거짓입니다).

참고 : 속성 이름이 이상한 경우 vendor.Name 대신 vendor [ "Name"]를 사용하고 있습니다.

참고 2 : 이름을 확인할 때 엄격한 동등 (===) 대신 느슨한 동등 (==)을 사용할 이유가 없습니다.

받아 들여진 대답은 여전히 ​​작동하지만 이제 [Array.find][1]동일한 효과를 얻는 ECMAScript 6 기본 방법 이 있습니다.

인용 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 링크 보기 mozilla가 제공하는 IE 용 polyfill이 있습니다.

내가 할 방법은 다음과 같습니다

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발견되지 않은 경우.

OP가 키의 존재 여부 를 물었다 .

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

너무 늦을 수 있지만 자바 스크립트 배열이 두 가지 방법을 가지고있다 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: 테스트 인 콜백 함수를 가져오고 배열은 is 콜백으로 반복되고이 콜백에 따라 필터링됩니다. 새로운 필터링 된 배열이 반환됩니다.
2. Array.prototype.some: 테스트 인 콜백 함수를 가져오고 배열은 is 콜백으로 반복되며 어떤 요소가 테스트를 통과 하면 부울 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기능이며 모든 브라우저에서 지원하지는 않습니다. 이를 극복하기 위해 폴리 필을 사용할 수 있습니다. Array.prototype.someMDN 의 polyfill은 다음과 같습니다 .

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

한 객체를 다른 객체와 비교하는 다른 방법은 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);

정확한 질문에 대답하기 위해 객체에서 값을 검색하는 경우 단일 루프를 사용할 수 있습니다.

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

결과 : without2 ([{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;
}

전화 / 사용

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