У масиві об'єктів найшвидший спосіб знайти індекс об'єкта, атрибути якого відповідають пошуку

Я займався серфінгом трохи, намагаючись знайти ефективний спосіб зробити це, але ніде не потрапив. У мене є масив об'єктів, який виглядає приблизно так:

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

редагувати: варто відзначити, що обидві ці функції просто ітерують під капотом, між ними не буде помітної різниці в продуктивності та прокатки власної функції фільтра, але чому знову винаходити колесо.

Якщо ви дбаєте про продуктивність, не йде з знахідкою або фільтром або карти або будь-які з розглянутих вище методів

Ось приклад, що демонструє найшвидший метод. ТУТ - посилання на власне тест

Блок налаштування

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

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

результат - список пошуку для ідентифікатора. із заданим ідентифікатором отримуємо індекс запису.

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

Оскільки за допомогою звичайного масиву немає відповіді 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

Новий спосіб використання ES6

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

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

Мені здається, що ви можете створити простий ітератор із зворотним дзвоном для тестування. Так:

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

Адаптувавши відповідь Тейса для mongoDB та Robomongo, я змінив

matchingIndices.push(j);

до

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

Використання функції ES6 map:

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

Підсумовуючи чудову відповідь, подану вище, та додаткову відповідь щодо пошуку всіх індексів, які відбулися з деяких коментарів.

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

Оскільки я поки не можу коментувати, я хочу показати рішення, яке я використав на основі опублікованого методом Umair Ahmed, але коли ви хочете шукати ключ замість значення:

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

Я розумію, що він не відповідає на розширене запитання, але в заголовку не вказано, що потрібно від кожного об'єкта, тому я хочу покірно поділитися цим, щоб зберегти головний біль іншим у майбутньому, хоча я скасовую, що це не може бути найшвидше рішення.

Я створив крихітну утиліту під назвою super-масив, де ви можете отримати доступ до елементів масиву за допомогою унікального ідентифікатора зі складністю O (1). Приклад:

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

поверне індекс 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 );