Jaka jest najlepsza metoda uzyskania indeksu tablicy zawierającej obiekty?

Wyobraź sobie ten scenariusz:

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

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

Chciałbym teraz, aby indexOfobiekt miał hellowłaściwość, 'stevie'która w tym przykładzie byłaby 1.

Jestem całkiem nowym użytkownikiem JavaScript i nie wiem, czy istnieje prosta metoda, czy też powinienem zbudować własną funkcję, aby to zrobić.

Myślę, że możesz rozwiązać go w jednym wierszu za pomocą funkcji mapy :

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

Array.prototype.findIndex jest obsługiwany we wszystkich przeglądarkach innych niż IE (non-edge). Ale podany polifill jest fajny.

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

Rozwiązanie z mapą jest w porządku. Ale iterujesz po całej tablicy przy każdym wyszukiwaniu. To tylko najgorszy przypadek dla findIndex, który przestaje iterować po znalezieniu dopasowania.

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

lub jako funkcja:

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

Tylko kilka notatek:

1. Nie używaj do ... w pętlach na tablicach
2. Pamiętaj, aby wyjść z pętli lub powrócić z funkcji po znalezieniu „igły”
3. Uważaj na równość obiektów

Na przykład,

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

W ES2015 jest to dość łatwe:

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

lub prawdopodobnie z lepszą wydajnością dla większych tablic:

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

Podoba mi się odpowiedź Pablo, ale Array # indexOf i Array # map nie działają we wszystkich przeglądarkach. Podkreślenie użyje kodu natywnego, jeśli jest dostępny, ale ma również awarie. Dodatkowo ma metodę wyrywkową do robienia dokładnie tego, co robi anonimowa metoda mapy Pablo.

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

Lub prototypuj:

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

Krótki

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

Przypadków użycia :

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

Zrobiłem tutaj testy wydajności różnych odpowiedzi, które każdy może samodzielnie uruchomić:

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

Na podstawie moich pierwszych testów w Chrome następująca metoda (użycie pętli for skonfigurowanej w prototypie) jest najszybsza:

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

Ten kod jest nieco zmodyfikowaną wersją odpowiedzi Nathana Zaetty.

W testach wydajności wypróbowałem go zarówno z celem znajdującym się pośrodku (indeks 500), jak i na samym końcu (indeks 999) tablicy obiektów 1000, a nawet jeśli wstawię cel jako ostatni element tablicy (co oznacza że musi przechodzić przez każdy element w tablicy, zanim zostanie znaleziony), wciąż kończy się najszybciej.

Zaletą tego rozwiązania jest to, że jest jednym z najbardziej zwięzłych do wielokrotnego wykonywania, ponieważ należy powtórzyć tylko ostatnią linię:

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

Porównałem kilka metod i uzyskałem wynik w najszybszy sposób na rozwiązanie tego problemu. To jest forpętla. Jest ponad 5 razy szybszy niż jakakolwiek inna metoda.

Oto strona testu: https://jsbench.me/9hjewv6a98

Chociaż większość innych odpowiedzi tutaj jest poprawnych. Czasami najlepiej jest po prostu zrobić krótką, prostą funkcję w pobliżu miejsca, gdzie będziesz jej używać.

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

To zależy od tego, co jest dla Ciebie ważne. Może oszczędzać wiersze kodu i bardzo sprytnie jest korzystać z jednowierszowego lub umieszczać ogólne rozwiązanie gdzieś, które obejmuje różne przypadki brzegowe. Ale czasem lepiej jest po prostu powiedzieć: „tutaj zrobiłem to w ten sposób”, niż pozostawić przyszłym programistom dodatkowe prace inżynierii odwrotnej. Zwłaszcza jeśli uważasz się za „nowicjusza” jak w swoim pytaniu.

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

Uważaj na [0].

Należy używać reducejak wAntonio Laguna odpowiedzi.

Przepraszamy za zwięzłość ...

Jeśli twój obiekt jest tym samym obiektem, którego używasz w tablicy, powinieneś być w stanie uzyskać indeks obiektu w taki sam sposób, jak robisz to tak, jakby to był ciąg znaków.

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

Spróbuj tego:

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

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

prosty:

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

Jeśli jesteś zainteresowany tylko znalezieniem stanowiska, zobacz odpowiedź @ Pablo .

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

Jednakże, jeśli nie możesz się doczekać znalezienia elementu (tj. Jeśli zastanawiasz się nad zrobieniem czegoś takiego myArray[pos]), istnieje bardziej efektywny, jednowierszowy sposób, używając tego filter.

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

Zobacz wyniki wydajności (~ + 42% operacji / s): http://jsbench.github.io/#7fa01f89a5dc5cc3bee79abfde80cdb3

Zobacz ten przykład: http://jsfiddle.net/89C54/

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

Zaczyna się od zera.

Zrobiłem ogólną funkcję, aby sprawdzić, czy poniżej jest kod i działa dla każdego obiektu

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

Pierwszy alert zwróci -1 (oznacza, że ​​nie znaleziono dopasowania), a drugi alert zwróci 0 (oznacza, że ​​znaleziono dopasowanie).

Użyj _.findIndexz biblioteki underscore.js

Oto przykład _.findIndex([{a:1},{a: 2,c:10},{a: 3}], {a:2,c:10}) //1

Używając findIndexmetody ES6 , bez lodash ani żadnych innych bibliotek, możesz napisać:

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

Spowoduje to porównanie bezpośrednich właściwości obiektu, ale nie powtórzy się we właściwościach.

Jeśli twoja implementacja findIndexjeszcze nie zapewnia (większość tego nie robi), możesz dodać lekki wypełniacz, który obsługuje to wyszukiwanie:

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

(z mojej odpowiedzi na ten duplikat )

Array.prototype.findIndex()Zasadniczo możesz korzystać z natywnej i wygodnej funkcji :

Metoda findIndex () zwraca indeks w tablicy, jeśli element w tablicy spełnia podaną funkcję testową. W przeciwnym razie zwracane jest -1.

Uwaga: nie jest obsługiwana w przeglądarkach Internet Explorer, Opera i Safari, ale możesz skorzystać z funkcji Polyfill podanej w poniższym linku.

Więcej informacji:

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

Oprócz odpowiedzi @Monika Garg możesz użyć findIndex()(Istnieje wiele wypełniaczy dla niepoprawnych przeglądarek).

Widziałem, że ludzie głosowali za tą odpowiedzią i mam nadzieję, że zrobili to z powodu złej składni, ponieważ moim zdaniem jest to najbardziej elegancki sposób.

Metoda findIndex () zwraca indeks w tablicy, jeśli element w tablicy spełnia podaną funkcję testową. W przeciwnym razie zwracane jest -1.

Na przykład:

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

W ten sposób można znaleźć indeks obiektu w tablicy

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

Działa to bez niestandardowego kodu

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

Uwaga: to nie daje rzeczywistego indeksu, informuje tylko, czy Twój obiekt istnieje w bieżącej strukturze danych

Możesz po prostu użyć

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

Bez podkreślenia, nie dla, po prostu redukcja.

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

Aby to zrobić, możesz stworzyć własny prototyp:

coś jak:

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

Wolę użyć findIndex()metody:

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

index poda ci numer indeksu.