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

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

다음과 같은 배열이 있습니다.

vendors = [{
    Name: 'Magenic',
    ID: 'ABC'Javascript 배열에 지정된 값과 동일한 속성을 가진 개체가 포함되어 있는지 확인하는 방법은 무엇입니까?
  },
  {
    Name: 'Microsoft',
    ID: 'DEF'
  } // and so on... 
];

이 어레이를 체크하여 "Magenic"이 존재하는지 확인하는 방법꼭 해야 하는 경우가 아니라면 루프하고 싶지 않아잠재적으로 수천 장의 음반으로 작업하고 있어요

적어도 명시적으로 휠 루프를 재창조할 필요는 없습니다(화살표 기능, 최신 브라우저만 사용).

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.find(e => e.Name === 'Magenic')) {
  /* same result as above, but a different function return type */
}

또한 findIndex를 사용하여 해당 요소의 위치를 확인할 수도 있습니다.

const i = vendors.findIndex(e => e.Name === 'Magenic');
if (i > -1) {
  /* vendors contains the element we're looking for, at index "i" */
}

또, 서투른 브라우저와의 호환성이 필요한 경우는, 다음과 같이 하는 것이 최선책이 있습니다.

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

2018년 편집:이 답변은 브라우저가 어레이 필터링 방법 및 화살표 기능을 광범위하게 지원하기 전인 2011년부터입니다.CAFX의 답변을 보세요.

루프가 없는 어레이에서 무언가를 확인하는 "매직" 방법은 없습니다.어떤 함수를 사용하더라도 함수 자체는 루프를 사용합니다.필요한 것을 찾는 즉시 루프를 벗어나 계산 시간을 최소화할 수 있습니다.

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

루프가 필요 없습니다.다음 세 가지 방법이 생각납니다.

Array.protype.some()

이것은 당신의 질문에 대한 가장 정확한 대답입니다. 즉, "뭔가 존재하는지 확인"하는 것으로, bool 결과를 암시합니다.이는 'Magenic' 객체가 있는 경우 true이고 그렇지 않은 경우 false입니다.

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

Array.protype.필터()

이렇게 하면 모든 '매지닉' 객체의 배열이 반환됩니다(단일 요소 배열이 반환됨).

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

빈 배열('Magenic' 오브젝트 없음)은 아직 truthy이기 때문에 이것을 부울로 강제하려고 해도 동작하지 않습니다. 그냥 쓰세요.magenicVendors.length조건부로요.

Array.protype.find()

첫 ' 객체 'Magenic' 객체)가 반환됩니다.undefined[ ] :

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

, OKtruthy, 「OK」, 「Truthy」)가 됩니다.undefined거짓입니다).

---

주의: 벤더 대신 벤더[이름]를 사용하고 있습니다.부동산 이름의 이상한 대문자 때문에 이름이 붙여졌습니다.

주 2: 이름을 확인할 때 엄밀한 등호(===) 대신 느슨한 등호(==)를 사용할 이유가 없습니다.

하지만, 6 .[Array.find][1] ★★★★★★★★★★★★★★★★★」[Array.some][2]을 사용하다

어레이.일부

some 요소가 존재하는지 판별하는 경우)가 합니다.true/false★★★★★★ 。

MDN 견적:

some() 메서드는 어레이 내의 적어도1개의 요소가 지정된 함수에 의해 구현된 테스트에 합격했는지 여부를 테스트합니다.지정된 함수가 true를 반환하는 요소를 어레이에서 찾으면 true를 반환하고 그렇지 않으면 false를 반환합니다.어레이는 변경되지 않습니다.

Array.find

않으면 find가 됩니다. 그렇지 않으면 반환됩니다.undefined.

MDN 견적:

find() 메서드는 지정된 테스트 함수를 충족하는 지정된 배열의 첫 번째 요소 값을 반환합니다.테스트 함수를 충족하는 값이 없으면 정의되지 않은 값이 반환됩니다.

var arr = [
  {
    id: 21,
    label: 'Banana',
  },
  {
    id: 22,
    label: 'Apple',
  }
]

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

my jsfiddle 링크를 참조하십시오.모질라에서 제공하는 IE용 폴리필이 있습니다.

내가 할 수 있는 방법은 이렇다.

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 의 사양에 따라서, 를 사용할 수 있습니다.

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

magenicIndex어느쪽이든 견딜 수 있다0 내의 ) (어레이 내의 인덱스)-1발발면면면면면면면면

늦었을 수도 있지만 에는 두 방법이 .some ★★★★★★★★★★★★★★★★★」every부울을 반환하고 이를 달성하는 데 도움이 되는 메서드입니다.

생각에는some당신이 성취하고자 하는 것에 가장 적합할 것입니다.

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

일부에서는 어레이 내의 모든 개체가 지정된 조건을 충족하는지 확인합니다.

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

모두 어레이 내의 모든 개체가 지정된 조건을 충족하는지 확인합니다.

OP가 키 유무에 대한 질문을 했기 때문에.

ES6 축소 함수를 사용하여 부울을 반환하는 보다 우아한 솔루션은 다음과 같습니다.

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

주의: reduce의 초기 파라미터는false사실

보다 효율적이고 깨끗한 코드 구현에 도움이 되기를 바랍니다.

사물을 제대로 들여다보지 않고는 할 수 없다.

구조를 좀 바꿔야 할 것 같아

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

그러면 조회 해시처럼 사용하면 됩니다.

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

어레이 요소 테스트:

JS 비교적 쉽게 이 작업을 수행할 수 있는 배열 기능을 제공합니다.그 예는 다음과 같습니다.

1. Array.prototype.filter: 테스트인 콜백 함수를 사용하여 어레이를 반복하고 이 콜백에 따라 필터링합니다.필터링된 새 배열이 반환됩니다.
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일부 브라우저가 지원하지 않을 수 있습니다.이를 극복하기 위해 폴리필을 사용할 수 있습니다. 이 .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;
  };
}

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

console.log(check)

이 코드를 사용해 보세요.

항목 또는 요소가 있으면 출력에 해당 요소가 표시됩니다.이 파일이 없으면 출력이 '정의되지 않음' 상태가 됩니다.

2021 솔루션*

.some(clean solution)은 클린솔루션입니다._matchesProperty(구체적) 줄임말:

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

설명.

'아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아VENDORS 배열은 다음과 같습니다.Name String 을 키'Magenic'true복을멈멈 멈멈멈다다수 를 반환한다.false.

코드 스니펫

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가장 심플한/최소한의 솔루션을 실현하는 라이브러리입니다.기존 바닐라 JS 솔루션의 대안으로 관심 있는 분들을 위해 제공합니다.

지금까지 가장 간단한 방법:

if (vendors.findIndex(item => item.Name == "Magenic") == -1) {
  //not found item
} else {
  //found item 
}

넌 루프를 돌려야 해, 피할 방법이 없어.

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가 직진 루프보다 빠를지는 의문이지만, 상황이 조금 복잡해지면 확실히 유연해집니다.

틀렸다면 정정해 주세요.나는 사용할 수 있었다.forEach, 이런 방법,

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

   }
});

요즘 나는 그것에 익숙하다. 왜냐하면 그것은 간단하고 자기 설명적인 단어이기 때문이다.감사해요.

이 문제를 해결하기 위한 나의 접근법은 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

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

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

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 in loop(오브젝트를 루프하기 위해 사용)과 somet()을 조합합니다.어레이가 경계를 벗어나는 등의 걱정을 할 필요가 없기 때문에 코드를 절약할 수 있습니다.의 메뉴얼은, 여기를 참조해 주세요.

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를 사용하여 루프를 네스트하여 어레이 내의 오브젝트 수를 취득하는 방법이 있습니다.아래 코드:

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 loop 를 사용할 수 있습니다.

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

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

차라리 regex로 하겠습니다.

당신의 코드가 다음과 같다면,

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

추천드립니다

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

언급URL : https://stackoverflow.com/questions/8217419/how-to-determine-if-javascript-array-contains-an-object-with-an-attribute-that-e