객체 배열에서 속성이 검색과 일치하는 객체의 인덱스를 찾는 가장 빠른 방법

객체 배열에서 속성이 검색과 일치하는 객체의 인덱스를 찾는 가장 빠른 방법

효율적인 방법을 찾기 위해 서핑을 좀 해봤지만 아무 것도 없었습니다.다음과 같은 형태의 객체 배열이 있습니다.

array[i].id = some number;
array[i].name = some name;

제가 하고 싶은 일은 id가 0,1,2,3 또는 4 중 하나와 같은 개체의 인덱스를 찾는 것입니다.저는 그저 다음과 같은 일을 할 수 있을 것 같습니다.

var indexes = [];
for(i=0; i<array.length; i++) {
  (array[i].id === 0) ? { indexes[0] = i }
  (array[i].id === 1) ? { indexes[1] = i }
  (array[i].id === 2) ? { indexes[2] = i }
  (array[i].id === 3) ? { indexes[3] = i }
  (array[i].id === 4) ? { indexes[4] = i }
}

이 방법은 효과가 있지만, 특히 array.length가 클 수 있는 경우에는 꽤 비싸고 느릴 것으로 보입니다.이것을 좀 더 다듬을 수 있는 방법에 대한 아이디어가 있습니까?array.indexOf를 사용해볼까 했는데 어떻게 하면 구문을 강제할 수 있을지 모르겠어요.

array.indexOf(this.id === 0);

예를 들어, 정의되지 않은 값을 반환합니다.

아마도 당신은 "지도"와 같은 고차 함수를 사용하고 싶을 것입니다.'field' 속성으로 검색할 경우:

var elementPos = array.map(function(x) {return x.id; }).indexOf(idYourAreLookingFor);
var objectFound = array[elementPos];

배열에서 요소 인덱스를 찾는 가장 간단하고 쉬운 방법.

ES5 구문: [{id:1},{id:2},{id:3},{id:4}].findIndex(function(obj){return obj.id == 3})

ES6 구문: [{id:1},{id:2},{id:3},{id:4}].findIndex(obj => obj.id == 3)

새로운 Array 메서드 .filter()가 이 작업에 적합합니다.

var filteredArray = array.filter(function (element) { 
    return element.id === 0;
});

jQuery는 .grep()을 사용하여 이 작업을 수행할 수도 있습니다.

편집: 이 두 기능 모두 후드 아래에서 반복적으로 작동하는 기능이며, 필터 기능을 직접 굴리는 것과 성능 차이가 눈에 띄게 나지는 않지만 휠을 다시 invent해야 하는 이유가 무엇인지를 언급할 필요가 있습니다.

성능에 관심이 있는 경우, 위에서 설명한 방법을 찾거나 필터링하거나 지도를 사용하지 마십시오.

다음은 가장 빠른 방법을 보여주는 예입니다.여기 실제 테스트 링크가 있습니다.

셋업블럭

var items = []

for(var i = 0; i < 1000; i++) {
    items.push({id: i + 1})
}

var find = 523

가장 빠른 방법

var index = -1
for(var i = 0; i < items.length; i++) {
    if(items[i].id === find) {
        index = i;
        break;
    }
}

느린 방법

items.findIndex(item => item.id === find)

가장 느린 방법

items.map(item => item.id).indexOf(find);

일반 배열을 사용하면 답이 없기 때문에find:

var one = {id: 1, name: 'one'};
var two = {id: 2, name:'two'}
var arr = [one, two] 
     
var found = arr.find((a) => a.id === 2) 

console.log(found === two) // true

console.log(arr.indexOf(found)) // 1

array.forEach(function (elem, i) {  // iterate over all elements of array
    indexes[elem.id] = i;           // take the found id as index for the
});                                 // indexes array and assign i

결과는 ID에 대한 조회 목록입니다. 주어진 ID로 레코드의 인덱스를 얻습니다.

const index = array.findIndex(item => item.id === 'your-id');

id === your-id로 정렬된 항목 인덱스를 얻을 수 있습니다.

array = [ {id:1}, {id:2} ];

const index = array.findIndex(item => item.id === 2);

console.log(index);

var indices = [];
var IDs = [0, 1, 2, 3, 4];

for(var i = 0, len = array.length; i < len; i++) {
    for(var j = 0; j < IDs.length; j++) {
        if(array[i].id == ID) indices.push(i);
    }
}

ES6를 사용하는 새로운 방법

let picked_element = array.filter(element => element.id === 0);

ES6 사용map함수:

let idToFind = 3;
let index = someArray.map(obj => obj.id).indexOf(idToFind);

@PirateBay에서 언급한 것처럼 때로는 옛날 방식이 가장 좋습니다.

ES 6/7을 사용하면 ".find"도 매우 빠르며 일치할 때 중지됩니다(.map 또는 .filter와 달리).

items.find(e => e.id === find)?.id

테스트용 콜백으로 간단한 반복기를 만들 수 있을 것 같네요.이와 같습니다.

function findElements(array, predicate)
{
    var matchingIndices = [];

    for(var j = 0; j < array.length; j++)
    {
        if(predicate(array[j]))
           matchingIndices.push(j);
    }

    return matchingIndices;
}

그러면 다음과 같이 호출할 수 있습니다.

var someArray = [
     { id: 1, text: "Hello" },
     { id: 2, text: "World" },
     { id: 3, text: "Sup" },
     { id: 4, text: "Dawg" }
  ];

var matchingIndices = findElements(someArray, function(item)
   {
        return item.id % 2 == 0;
   });

// Should have an array of [1, 3] as the indexes that matched

tejs의 답변을 mongoDB와 로보몽고에 맞게 수정한 것 I

matchingIndices.push(j);

로.

matchingIndices.push(NumberInt(j+1));

위의 모든 훌륭한 답변과 모든 인덱스 찾기에 대한 추가 답변을 요약하자면, 일부 코멘트로부터 발생한 것입니다.

1. 첫 번째 발생의 인덱스를 반환합니다.

const array = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 2 }];
const idYourAreLookingFor = 2;

//ES5 
//Output: 1
array.map(function (x) { return x.id; }).indexOf(idYourAreLookingFor);

//ES6 
//Output: 1
array.findIndex(obj => obj.id === idYourAreLookingFor);

2. 축소를 사용하여 모든 발생의 인덱스 배열을 반환합니다.

const array = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 2 }]
const idYourAreLookingFor = 2;

//ES5
//Output: [1, 4]
array.reduce(function (acc, obj, i) {
  if (obj.id === idYourAreLookingFor)
    acc.push(i);
  return acc;
}, []);

//ES6
//Output: [1, 4]
array.reduce((acc, obj, i) => (obj.id === idYourAreLookingFor) ? acc.concat(i) : acc, [])

저는 O(1) 복잡도의 고유 식별자를 사용하여 배열의 항목에 액세스할 수 있는 super-array라는 작은 유틸리티를 개발했습니다.예:

const SuperArray = require('super-array');

const myArray = new SuperArray([
  {id: 'ab1', name: 'John'},
  {id: 'ab2', name: 'Peter'},
]);

console.log(myArray.get('ab1')); // {id: 'ab1', name: 'John'}
console.log(myArray.get('ab2')); // {id: 'ab2', name: 'Peter'}

특정 일치를 기반으로 배열에서 개체 인덱스를 찾는 간단한 방법.

//list of bookings
const bookings = [
        { status: "accepted", _id: "6055cadd062eb5153c089121", title: "This is test               title", user: "id", team: "id" },
        { status: "pending", _id: "6055cb33062eb5153c089122", title: "title1",                   description: "test description", user: "id", team: "id" },
        { status: "accepted", _id: "6055cb3d062eb5153c089123", title: "title2",                   description: "test description", user: "id", team: "id" }
        ]
    
//return index of the element if find else return -1 
const findIndex = (booking) => bookings.findIndex((b, index) => {
        if (b._id === booking._id) return true    
})
        
//test 1
let booking = { status: "pending", _id: "6055cb33062eb5153c089122", title: "title2",             description: "test description", user: "id", team: "id" }
console.log("index >>> ", findIndex(booking))
//output : 1
    
//test 2
booking = { status: "rejected", _id: "6055cb33062eb5153c089198", title: "title3",                 description: "test description", user: "id", team: "id" }
console.log("index >>> ", findIndex(booking))
//output : -1
    
//test 3
const id = '6055cb3d062eb5153c089123'
console.log("index >>> ", findIndex({ _id: id }))
//output : 2

아직 언급할 수 없기 때문에 Umair Ahmed가 게시한 방법을 바탕으로 사용한 솔루션을 보여주고 싶지만 값이 아닌 키를 검색하고 싶을 때:

[{"a":true}, {"f":true}, {"g":false}]
.findIndex(function(element){return Object.keys(element)[0] == "g"});

확장된 질문에 답하지 않는 것은 이해하지만, 제목에 각각의 대상에게 무엇을 원했는지 명시된 것은 아니기 때문에, 저는 이것을 겸손하게 공유하여 미래의 다른 사람들에게 두통을 덜어주고 싶지만, 그것이 가장 빠른 해결책은 아닐 수도 있습니다.

var test = [
  {id:1, test: 1},
  {id:2, test: 2},
  {id:2, test: 2}
];

var result = test.findIndex(findIndex, '2');

console.log(result);

function findIndex(object) {
  return object.id == this;
}

인덱스 1을 반환합니다(ES 2016에서만 작동).

이 방법은 아무리 깊이 있게 중첩해도 객체의 어떤 값과도 비교하기가 쉬워 마음에 듭니다.

 while(i<myArray.length && myArray[i].data.value!==value){
  i++; 
}
// i now hows the index value for the match. 
 console.log("Index ->",i );

언급URL : https://stackoverflow.com/questions/10557486/in-an-array-of-objects-fastest-way-to-find-the-index-of-an-object-whose-attribu