W tablicy obiektów najszybszy sposób na znalezienie indeksu obiektu, którego atrybuty pasują do wyszukiwania

Trochę surfowałem po okolicy, próbując znaleźć skuteczny sposób, aby to zrobić, ale do niczego nie doszedłem. Mam tablicę obiektów, która wygląda następująco:

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

To, co chcę zrobić, to znaleźć INDEKSY obiektów, w których id jest równe, na przykład, jednemu z 0, 1, 2, 3 lub 4. Przypuszczam, że mógłbym zrobić coś takiego:

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

Chociaż to by zadziałało, wygląda na dość drogie i wolne (nie wspominając o brzydkim), zwłaszcza jeśli array.length może być duża. Jakieś pomysły, jak to trochę urozmaicić? Myślałem o użyciu w jakiś sposób array.indexOf, ale nie wiem, jak wymusić składnię. To

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

na przykład zwraca undefined, tak jak prawdopodobnie powinno. Z góry dziękuję!

Może chciałbyś użyć funkcji wyższego rzędu, takich jak „mapa”. Zakładając, że chcesz wyszukiwać według atrybutu „pole”:

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

Najprostszy i najłatwiejszy sposób na znalezienie indeksu elementu w tablicy.

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

Składnia ES6: [{id:1},{id:2},{id:3},{id:4}].findIndex(obj => obj.id == 3)

Nowa metoda Array .filter () będzie dobrze działać w tym przypadku:

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

jQuery może to również zrobić za pomocą .grep ()

edycja: warto wspomnieć, że obie te funkcje po prostu powtarzają się pod maską, nie będzie zauważalnej różnicy w wydajności między nimi i włączaniem własnej funkcji filtra, ale po co wymyślać koło na nowo.

Jeśli zależy Ci na wydajności, nie idź z znalezisku lub filtr lub map lub którykolwiek z wyżej omówionych metod

Oto przykład demonstrujący najszybszą metodę. TUTAJ jest link do właściwego testu

Blok konfiguracji

var items = []

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

var find = 523

Najszybsza metoda

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

Wolniejsze metody

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

NAJWOLNIEJSZA metoda

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

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

wynikiem jest lista wyszukiwania identyfikatora. z podanym id otrzymujemy indeks rekordu.

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

Ponieważ nie ma odpowiedzi przy użyciu zwykłej tablicy 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)

found === two // true

arr.indexOf(found) // 1

Nowy sposób korzystania z ES6

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

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

To powinno dać ci indeks pozycji w tablicy z id === twój-id

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

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

console.log(index);

Wydaje mi się, że możesz stworzyć prosty iterator z wywołaniem zwrotnym do testowania. Tak jak to:

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

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

    return matchingIndices;
}

Następnie możesz wywołać w ten sposób:

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

Dostosowując odpowiedź Tejsa do mongoDB i Robomongo zmieniłem

matchingIndices.push(j);

do

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

Korzystanie z mapfunkcji ES6 :

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

Podsumowując całą świetną odpowiedź powyżej i dodatkową moją odpowiedź dotyczącą znaleźć wszystkie indeksy pojawiły się z niektórych komentarzy.

1. Aby zwrócić indeks pierwszego wystąpienia.

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. Aby zwrócić tablicę indeksów wszystkich wystąpień, użyj funkcji redukuj.

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, [])

Ponieważ nie mogę jeszcze komentować, chcę pokazać rozwiązanie, które zastosowałem w oparciu o metodę opublikowaną przez Umair Ahmed, ale gdy chcesz wyszukać klucz zamiast wartości:

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

Rozumiem, że nie odpowiada na rozszerzone pytanie, ale tytuł nie określa, czego oczekiwano od każdego obiektu, więc chcę pokornie się tym podzielić, aby w przyszłości oszczędzić innym bólom głowy, podczas gdy ja nie rozumiem, że może to nie być najszybsze rozwiązanie.

Stworzyłem małe narzędzie o nazwie super-array, w którym można uzyskać dostęp do elementów w tablicy za pomocą unikalnego identyfikatora o złożoności O (1). Przykład:

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

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

zwróci indeks 1 (działa tylko w ES 2016)

Podoba mi się ta metoda, ponieważ łatwo jest porównać ją z dowolną wartością w obiekcie, niezależnie od tego, jak głęboko jest on zagnieżdżony.

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