In una matrice di oggetti, il modo più veloce per trovare l'indice di un oggetto i cui attributi corrispondono a una ricerca

Ho navigato un po 'cercando di trovare un modo efficiente per farlo, ma non sono arrivato da nessuna parte. Ho una serie di oggetti che assomiglia a questo:

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

Quello che voglio fare è trovare gli INDICI degli oggetti in cui id è uguale, ad esempio, a 0,1,2,3 o 4. Suppongo che potrei semplicemente fare qualcosa del tipo:

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

Mentre questo funzionerebbe, sembra essere piuttosto costoso e lento (per non parlare dei brutti), specialmente se array.length potrebbe essere grande. Qualche idea su come abbellirlo un po '? Ho pensato di usare array.index In qualche modo, ma non vedo come forzare la sintassi. Questo

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

ad esempio, restituisce undefined, come probabilmente dovrebbe. Grazie in anticipo!

Forse ti piacerebbe usare funzioni di ordine superiore come "map". Supponendo di voler cercare per attributo 'field':

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

Il modo più semplice e facile per trovare l'indice degli elementi nell'array.

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

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

Il nuovo metodo Array .filter () funzionerebbe bene per questo:

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

jQuery può anche farlo con .grep ()

modifica: vale la pena ricordare che entrambe queste funzioni eseguono l'iterazione sotto il cofano, non ci sarà una notevole differenza di prestazioni tra loro e il rotolamento della propria funzione di filtro, ma perché reinventare la ruota.

Se ti preoccupi delle prestazioni, non andare con find o filter o map o con uno dei metodi sopra discussi

Ecco un esempio che dimostra il metodo più veloce. QUI è il link al test effettivo

Blocco di installazione

var items = []

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

var find = 523

Metodo più veloce

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

Metodi più lenti

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

Metodo più lento

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

il risultato è un elenco di ricerca per l'id. con l'id specificato otteniamo l'indice del record.

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

Poiché non vi è alcuna risposta utilizzando l'array normale 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

Un nuovo modo di usare ES6

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

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

Questo dovrebbe farti ottenere l'indice dell'articolo nell'array con id === your-id

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

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

console.log(index);

Mi sembra che potresti creare un semplice iteratore con un callback per il test. Così:

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

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

    return matchingIndices;
}

Quindi potresti invocare in questo modo:

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

Adattando la risposta di Tejs per mongoDB e Robomongo ho cambiato

matchingIndices.push(j);

per

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

Utilizzando la mapfunzione ES6 :

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

Per riassumere tutta la grande risposta sopra e ulteriore della mia risposta per quanto riguarda trova tutti gli indici occorsi da alcuni dei commenti.

1. Per restituire l'indice della prima occorrenza.

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. Per restituire la matrice dell'indice di tutte le occorrenze, usando il comando riduci.

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

Poiché non posso ancora commentare, voglio mostrare la soluzione che ho usato in base al metodo pubblicato da Umair Ahmed, ma quando si desidera cercare una chiave anziché un valore:

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

Capisco che non risponde alla domanda espansa, ma il titolo non specifica ciò che era desiderato da ciascun oggetto, quindi voglio condividerlo umilmente per salvare il mal di testa agli altri in futuro, mentre riesco a non avviarlo potrebbe non essere il soluzione più veloce.

Ho creato una piccola utility chiamata super-array in cui è possibile accedere agli elementi in un array tramite un identificatore univoco con complessità O (1). Esempio:

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

restituirà l'indice 1 (funziona solo in ES 2016)

Mi piace questo metodo perché è facile paragonarlo a qualsiasi valore nell'oggetto, non importa quanto profondo sia nidificato.

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