Was ist die beste Methode, um den Index eines Arrays zu erhalten, das Objekte enthält?

Stellen Sie sich dieses Szenario vor:

var hello = {
    hello: 'world',
    foo: 'bar'
};
var qaz = {
    hello: 'stevie',
    foo: 'baz'
}

var myArray = [];
myArray.push(hello,qaz);

Jetzt möchte ich das indexOfObjekt haben, welche helloEigenschaft 'stevie'welche ist, in diesem Beispiel 1.

Ich bin ein ziemlich Neuling in JavaScript und ich weiß nicht, ob es eine einfache Methode gibt oder ob ich meine eigene Funktion dafür erstellen sollte.

Ich denke, Sie können es in einer Zeile mit der Kartenfunktion lösen :

pos = myArray.map(function(e) { return e.hello; }).indexOf('stevie');

Array.prototype.findIndex wird in allen Browsern außer IE (ohne Edge) unterstützt. Aber die bereitgestellte Polyfüllung ist schön.

var indexOfStevie = myArray.findIndex(i => i.hello === "stevie");

Die Lösung mit Karte ist okay. Sie iterieren jedoch bei jeder Suche über das gesamte Array. Dies ist nur der schlechteste Fall für findIndex, der die Iteration beendet, sobald eine Übereinstimmung gefunden wurde.

var searchTerm = "stevie",
    index = -1;
for(var i = 0, len = myArray.length; i < len; i++) {
    if (myArray[i].hello === searchTerm) {
        index = i;
        break;
    }
}

oder als Funktion:

function arrayObjectIndexOf(myArray, searchTerm, property) {
    for(var i = 0, len = myArray.length; i < len; i++) {
        if (myArray[i][property] === searchTerm) return i;
    }
    return -1;
}
arrayObjectIndexOf(arr, "stevie", "hello"); // 1

Nur ein paar Anmerkungen:

1. Nicht für ... in Schleifen auf Arrays verwenden
2. Stellen Sie sicher, dass Sie aus der Schleife ausbrechen oder aus der Funktion zurückkehren, sobald Sie Ihre "Nadel" gefunden haben.
3. Seien Sie vorsichtig mit der Objektgleichheit

Zum Beispiel,

var a = {obj: 0};
var b = [a];
b.indexOf({obj: 0}); // -1 not found

In ES2015 ist dies ziemlich einfach:

myArray.map(x => x.hello).indexOf('stevie')

oder wahrscheinlich mit besserer Leistung für größere Arrays:

myArray.findIndex(x => x.hello === 'stevie')

var idx = myArray.reduce( function( cur, val, index ){

    if( val.hello === "stevie" && cur === -1 ) {
        return index;
    }
    return cur;

}, -1 );

Ich mag Pablos Antwort, aber Array # indexOf und Array # map funktionieren nicht in allen Browsern. Unterstrich verwendet nativen Code, sofern dieser verfügbar ist, weist jedoch auch Fallbacks auf. Außerdem verfügt es über die Zupfmethode, mit der genau das ausgeführt wird, was die anonyme Kartenmethode von Pablo bewirkt.

var idx = _.chain(myArray).pluck("hello").indexOf("Stevie").value();

Oder Prototyp:

Array.prototype.indexOfObject = function arrayObjectIndexOf(property, value) {
    for (var i = 0, len = this.length; i < len; i++) {
        if (this[i][property] === value) return i;
    }
    return -1;
}

myArr.indexOfObject("name", "stevie");

Kurz

myArray.indexOf('stevie','hello')

Anwendungsfälle :

  /*****NORMAL****/  
[2,4,5].indexOf(4) ;//OUTPUT 1
 /****COMPLEX*****/
 [{slm:2},{slm:4},{slm:5}].indexOf(4,'slm');//OUTPUT 1
 //OR
 [{slm:2},{slm:4},{slm:5}].indexOf(4,function(e,i){
   return e.slm;
});//OUTPUT 1
/***MORE Complex**/
[{slm:{salat:2}},{slm:{salat:4}},{slm:{salat:5}}].indexOf(4,function(e,i){
   return e.slm.salat;
});//OUTPUT 1

API:

    Array.prototype.indexOfOld=Array.prototype.indexOf

    Array.prototype.indexOf=function(e,fn){
      if(!fn){return this.indexOfOld(e)}
      else{ 
       if(typeof fn ==='string'){var att=fn;fn=function(e){return e[att];}}
        return this.map(fn).indexOfOld(e);
      }
    };

Ich habe hier einige Leistungstests mit verschiedenen Antworten durchgeführt, die jeder selbst ausführen kann:

https://jsperf.com/find-index-of-object-in-array-by-contents

Basierend auf meinen ersten Tests in Chrome ist die folgende Methode (unter Verwendung einer in einem Prototyp eingerichteten for-Schleife) die schnellste:

Array.prototype.indexOfObject = function (property, value) {
    for (var i = 0, len = this.length; i < len; i++) {
        if (this[i][property] === value) return i;
    }
    return -1;
}

myArray.indexOfObject("hello", "stevie");

Dieser Code ist eine leicht modifizierte Version von Nathan Zaettas Antwort.

In den Leistungsbenchmarks habe ich es versucht, wobei sich das Ziel sowohl in der Mitte (Index 500) als auch am Ende (Index 999) eines 1000-Objekt-Arrays befand, und selbst wenn ich das Ziel als allerletztes Element in das Array eingefügt habe (dh) dass es jedes einzelne Element im Array durchlaufen muss, bevor es gefunden wird), endet es immer noch am schnellsten.

Diese Lösung hat auch den Vorteil, dass sie eine der knappsten für die wiederholte Ausführung ist, da nur die letzte Zeile wiederholt werden muss:

myArray.indexOfObject("hello", "stevie");

Ich habe mehrere Methoden verglichen und ein Ergebnis mit dem schnellsten Weg zur Lösung dieses Problems erhalten. Es ist einfor Schleife. Es ist mehr als fünfmal schneller als jede andere Methode.

Hier ist die Testseite: https://jsbench.me/9hjewv6a98

Die meisten anderen Antworten hier sind gültig. Manchmal ist es am besten, eine kurze einfache Funktion in der Nähe des Verwendungsortes zu erstellen.

// indexOf wrapper for the list of objects
function indexOfbyKey(obj_list, key, value) {
    for (index in obj_list) {
        if (obj_list[index][key] === value) return index;
    }
    return -1;
}
// Find the string in the list (default -1)
var test1 = indexOfbyKey(object_list, 'name', 'Stevie');
var test2 = indexOfbyKey(object_list, 'last_name', 'some other name');

Es kommt darauf an, was Ihnen wichtig ist. Es kann Codezeilen speichern und sehr klug sein, einen Einzeiler zu verwenden oder eine generische Lösung zu platzieren, die verschiedene Randfälle abdeckt. Aber manchmal ist es besser, einfach zu sagen: "Hier habe ich es so gemacht", als zukünftige Entwickler zusätzlichen Reverse Engineering-Arbeiten zu überlassen. Vor allem, wenn Sie sich wie in Ihrer Frage als "Neuling" betrachten.

array.filter(function(item, indx, arr){ return(item.hello === 'stevie'); })[0];

Kümmere dich um das [0].

Es ist richtig zu verwenden reducewie inAntonio Laguna der Antwort zu verwenden.

Entschuldigung für die Kürze ...

Wenn Ihr Objekt dasselbe Objekt ist wie das, das Sie innerhalb des Arrays verwenden, sollten Sie in der Lage sein, den Index des Objekts auf dieselbe Weise abzurufen, als wäre es eine Zeichenfolge.

var hello = {
    hello: 'world',
    foo: 'bar'
};
var qaz = {
    hello: 'stevie',
    foo: 'baz'
}

var qazCLONE = { // new object instance and same structure
    hello: 'stevie',
    foo: 'baz'
}

var myArray = [hello,qaz];

myArray.indexOf(qaz) // should return 1
myArray.indexOf(qazCLONE) // should return -1

Versuche dies:

console.log(Object.keys({foo:"_0_", bar:"_1_"}).indexOf("bar"));

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

einfach:

myArray.indexOf(myArray.filter(function(item) {
    return item.hello == "stevie"
})[0])

Wenn Sie nur daran interessiert sind, die Position zu finden, lesen Sie die Antwort von @ Pablo .

pos = myArray.map(function(e) { return e.hello; }).indexOf('stevie');

Wenn Sie sich jedoch darauf freuen , das Element zu finden (dh wenn Sie daran gedacht haben, so etwas zu tun myArray[pos]), gibt es eine effizientere einzeilige Möglichkeit, dies zu tun filter.

element = myArray.filter((e) => e.hello === 'stevie')[0];

Siehe Leistungsergebnisse (~ + 42% ops / s): http://jsbench.github.io/#7fa01f89a5dc5cc3bee79abfde80cdb3

Siehe dieses Beispiel: http://jsfiddle.net/89C54/

for (i = 0; i < myArray.length; i++) {
    if (myArray[i].hello === 'stevie') {
        alert('position: ' + i);
        return;
    }
}

Es beginnt mit Null zu zählen.

Ich habe eine generische Funktion erstellt, um zu überprüfen, ob der folgende Code für jedes Objekt funktioniert

function indexOfExt(list, item) {
    var len = list.length;

    for (var i = 0; i < len; i++) {
        var keys = Object.keys(list[i]);
        var flg = true;
        for (var j = 0; j < keys.length; j++) {
            var value = list[i][keys[j]];
            if (item[keys[j]] !== value) {
                flg = false;
            }
        }
        if (flg == true) {
            return i;
        }
    }
    return -1;
}

var items = [{ "hello": 'world', "foo": 'bar' }];
var selectedItem = { "hello": 'world', "foo": 'bar' };
alert(items.indexOf(selectedItem));
alert(indexOfExt(items, selectedItem));

Die erste Warnung gibt -1 zurück (bedeutet Übereinstimmung nicht gefunden) und die zweite Warnung gibt 0 zurück (bedeutet Übereinstimmung gefunden).

Verwendung _.findIndexaus der Bibliothek underscore.js

Hier ist das Beispiel _.findIndex([{a:1},{a: 2,c:10},{a: 3}], {a:2,c:10}) //1

Mit der ES6- findIndexMethode können Sie ohne lodash oder andere Bibliotheken schreiben:

function deepIndexOf(arr, obj) {
  return arr.findIndex(function (cur) {
    return Object.keys(obj).every(function (key) {
      return obj[key] === cur[key];
    });
  });
}

Dadurch werden die unmittelbaren Eigenschaften des Objekts verglichen, jedoch nicht in die Eigenschaften zurückgeführt.

Wenn Ihre Implementierung noch keine bereitstellt findIndex(die meisten nicht), können Sie eine leichte Polyfüllung hinzufügen, die diese Suche unterstützt:

function deepIndexOf(arr, obj) {
  function findIndex = Array.prototype.findIndex || function (pred) {
    for (let i = 0; i < this.length; ++i) {
      if (pred.call(this, this[i], i)) {
        return i;
      }
    }

    return -1;
  }

  return findIndex.call(arr, function (cur) {
    return Object.keys(obj).every(function (key) {
      return obj[key] === cur[key];
    });
  });
}

(Aus meiner Antwort auf diesen Betrug )

Sie können Array.prototype.findIndex()grundsätzlich eine native und bequeme Funktion verwenden :

Die Methode findIndex () gibt einen Index im Array zurück, wenn ein Element im Array die bereitgestellte Testfunktion erfüllt. Andernfalls wird -1 zurückgegeben.

Nur ein Hinweis, es wird in Internet Explorer, Opera und Safari nicht unterstützt, aber Sie können eine Polyfüllung verwenden, die unter dem folgenden Link bereitgestellt wird.

Mehr Informationen:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex

var hello = {
  hello: 'world',
  foo: 'bar'
};
var qaz = {
  hello: 'stevie',
  foo: 'baz'
}

var myArray = [];
myArray.push(hello, qaz);

var index = myArray.findIndex(function(element, index, array) {
  if (element.hello === 'stevie') {
    return true;
  }
});
alert('stevie is at index: ' + index);

Weitere Antwort von @Monika Garg können Sie verwenden findIndex()(Es gibt eine Polyfüllung für unsupprted Browser).

Ich habe gesehen, dass die Leute diese Antwort abgelehnt haben, und ich hoffe, dass sie dies aufgrund der falschen Syntax getan haben, weil dies meiner Meinung nach der eleganteste Weg ist.

Die Methode findIndex () gibt einen Index im Array zurück, wenn ein Element im Array die bereitgestellte Testfunktion erfüllt. Andernfalls wird -1 zurückgegeben.

Zum Beispiel:

var hello = {
  hello: 'world',
  foo: 'bar'
};
var qaz = {
  hello: 'stevie',
  foo: 'baz'
}

var myArray = [];
myArray.push(hello,qaz);

var index = myArray.findIndex(function(element) {
  return element.hello == 'stevie';
});

alert(index);

Auf diese Weise finden Sie den Index des Objekts im Array

    var myArray = [{  hello: 'world',
        foo: 'bar'
    },{
        hello: 'stevie',
        foo: 'baz'
    }];



    for (i = 0; i < myArray.length; i++) {
        if (myArray[i].hello === 'stevie') {
            alert('position: ' + i);
            return;
        }
    }

Dies funktioniert ohne benutzerdefinierten Code

var arr, a, found;
arr = [{x: 1, y: 2}];
a = {x: 1, y: 2};
found = JSON.stringify(arr).indexOf(JSON.stringify(a)) > - 1;
// found === true

Hinweis: Dies gibt nicht den tatsächlichen Index an, sondern gibt nur an, ob Ihr Objekt in der aktuellen Datenstruktur vorhanden ist

Sie können einfach verwenden

const someId = 2;
const array = [{id:1}, {id:2}, {id:3}];
const index = array.reduce((i, item, index) => item.id === someId ? index : i, -1);
alert('someId ' + someId + ' is at index ' + index);

Kein Unterstrich, nein für, nur eine Reduzierung.

var hello = {hello: "world",  foo: "bar"};
var qaz = {hello: "stevie", foo: "baz"};
var myArray = [];
myArray.push(hello,qaz);

function indexOfObject( arr, key, value   ) {
    var j = -1;
    var result = arr.some(function(obj, i) { 
        j++;
        return obj[key] == value;
    })

    if (!result) {
        return -1;
    } else {
        return j;
    };
}

alert(indexOfObject(myArray,"hello","world"));

Sie können dazu Ihren eigenen Prototyp erstellen:

etwas wie:

Array.prototype.indexOfObject = function (object) {
    for (var i = 0; i < this.length; i++) {
        if (JSON.stringify(this[i]) === JSON.stringify(object))
            return i;
    }
}

Ich werde es vorziehen, findIndex()Methode zu verwenden :

 var index = myArray.findIndex('hello','stevie');

index gibt Ihnen die Indexnummer.