In einem Array von Objekten der schnellste Weg, um den Index eines Objekts zu finden, dessen Attribute mit einer Suche übereinstimmen

Ich habe ein wenig herumgesurft, um einen effizienten Weg zu finden, bin aber nirgendwo hingekommen. Ich habe eine Reihe von Objekten, die so aussehen:

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

Was ich tun möchte, ist, die INDEXE der Objekte zu finden, bei denen id beispielsweise einem von 0,1,2,3 oder 4 entspricht. Ich nehme an, ich könnte einfach so etwas tun:

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

Dies würde zwar funktionieren, scheint aber ziemlich teuer und langsam zu sein (ganz zu schweigen von hässlich), insbesondere wenn array.length groß sein könnte. Irgendwelche Ideen, wie man das ein bisschen aufpeppen kann? Ich dachte daran, array.indexOf irgendwie zu verwenden, aber ich sehe nicht, wie ich die Syntax erzwingen soll. Dies

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

Gibt beispielsweise undefiniert zurück, wie es wahrscheinlich sollte. Danke im Voraus!

Vielleicht möchten Sie Funktionen höherer Ordnung wie "Karte" verwenden. Angenommen, Sie möchten nach dem Attribut "Feld" suchen:

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

Der einfachste und einfachste Weg, um einen Elementindex im Array zu finden.

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

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

Die neue Array-Methode .filter () würde dafür gut funktionieren:

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

jQuery kann dies auch mit .grep () tun

Bearbeiten: Es ist erwähnenswert, dass diese beiden Funktionen nur unter der Haube durchlaufen werden. Es gibt keinen merklichen Leistungsunterschied zwischen ihnen und dem Rollen Ihrer eigenen Filterfunktion, aber warum sollten Sie das Rad neu erfinden?

Wenn Sie über die Leistung kümmern, tun sie nicht mit gehen finden oder Filter oder Karte oder einen der oben diskutierten Verfahren

Hier ist ein Beispiel, das die schnellste Methode demonstriert. HIER ist der Link zum eigentlichen Test

Setup-Block

var items = []

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

var find = 523

Schnellste Methode

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

Langsamere Methoden

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

LANGSAMSTE Methode

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

Das Ergebnis ist eine Nachschlageliste für die ID. Mit der angegebenen ID erhalten wir den Index des Datensatzes.

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

Da es keine Antwort mit normalem Array gibt 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

Ein neuer Weg mit ES6

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

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

Dadurch sollten Sie den Index des Elements im Array mit der ID === your-id erhalten

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

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

console.log(index);

Klingt für mich so, als könnten Sie einen einfachen Iterator mit einem Rückruf zum Testen erstellen. Wie so:

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

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

    return matchingIndices;
}

Dann könnten Sie so aufrufen:

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

Ich habe Tejs 'Antwort für mongoDB und Robomongo angepasst und mich geändert

matchingIndices.push(j);

zu

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

Verwenden der ES6- mapFunktion:

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

Um alle oben genannten großartigen Antworten und zusätzlich meine Antwort bezüglich der Suche nach allen Indizes zusammenzufassen, die aus einigen Kommentaren hervorgegangen sind.

1. Rückgabe des Index des ersten Auftretens.

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. Verwenden Sie reduzieren, um das Indexarray aller Vorkommen zurückzugeben.

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

Da ich noch keinen Kommentar abgeben kann, möchte ich die Lösung zeigen, die ich basierend auf der von Umair Ahmed veröffentlichten Methode verwendet habe. Wenn Sie jedoch nach einem Schlüssel anstelle eines Werts suchen möchten:

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

Ich verstehe, dass es die erweiterte Frage nicht beantwortet, aber der Titel gibt nicht an, was von jedem Objekt gewünscht wurde. Deshalb möchte ich dies demütig teilen, um anderen in Zukunft Kopfschmerzen zu ersparen, während ich es nicht starten kann schnellste Lösung.

Ich habe ein kleines Dienstprogramm namens Super-Array erstellt, mit dem Sie über eine eindeutige Kennung mit O (1) -Komplexität auf Elemente in einem Array zugreifen können. Beispiel:

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

gibt Index 1 zurück (funktioniert nur in ES 2016)

Ich mag diese Methode, weil es einfach ist, sie mit jedem Wert im Objekt zu vergleichen, egal wie tief es verschachtelt ist.

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