¿Cuál es el mejor método para obtener el índice de una matriz que contiene objetos?

Imagina este escenario:

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

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

Ahora me gustaría tener el indexOfobjeto cuya hellopropiedad es 'stevie'cuál, en este ejemplo, sería 1.

Soy bastante novato con JavaScript y no sé si hay un método simple o si debería crear mi propia función para hacerlo.

Creo que puedes resolverlo en una línea usando la función de mapa :

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

Array.prototype.findIndex es compatible con todos los navegadores que no sean IE (no edge). Pero el polyfill proporcionado es agradable.

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

La solución con el mapa está bien. Pero está iterando sobre toda la matriz en cada búsqueda. Ese es solo el peor de los casos para findIndex, que deja de iterar una vez que se encuentra una coincidencia.

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

o como una función:

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

Solo algunas notas:

1. No lo use para ... en bucles en matrices
2. Asegúrese de salir del bucle o volver a salir de la función una vez que haya encontrado su "aguja"
3. Tenga cuidado con la igualdad de objetos.

Por ejemplo,

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

En ES2015, esto es bastante fácil:

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

o, probablemente con un mejor rendimiento para matrices más grandes:

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

Me gusta la respuesta de Pablo, pero Array # indexOf y Array # map no funcionan en todos los navegadores. El subrayado utilizará código nativo si está disponible, pero también tiene retrocesos. Además, tiene el método de extracción para hacer exactamente lo que hace el método de mapa anónimo de Pablo.

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

O prototipo:

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

Breve

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

Casos de uso:

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

Hice algunas pruebas de rendimiento de varias respuestas aquí, que cualquiera puede ejecutar por sí mismo:

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

Basado en mis pruebas iniciales en Chrome, el siguiente método (usando un bucle for configurado dentro de un prototipo) es el más rápido:

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

Este código es una versión ligeramente modificada de la respuesta de Nathan Zaetta.

En los puntos de referencia de rendimiento lo probé con el objetivo en el medio (índice 500) y el final (índice 999) de una matriz de 1000 objetos, e incluso si puse el objetivo como el último elemento de la matriz (lo que significa que tiene que recorrer cada uno de los elementos de la matriz antes de que se encuentre) todavía termina siendo el más rápido.

Esta solución también tiene el beneficio de ser una de las más concisas para ejecutar repetidamente, ya que solo la última línea necesita repetirse:

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

Comparé varios métodos y recibí un resultado con la forma más rápida de resolver este problema. Es un forbucle. Es más de 5 veces más rápido que cualquier otro método.

Aquí está la página de la prueba: https://jsbench.me/9hjewv6a98

Mientras, la mayoría de las otras respuestas aquí son válidas. A veces, es mejor hacer una función simple y corta cerca de donde la usará.

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

Depende de lo que sea importante para ti. Puede guardar líneas de código y ser muy inteligente para usar una línea, o para poner una solución genérica en algún lugar que cubra varios casos extremos. Pero a veces es mejor decir: "aquí lo hice así" en lugar de dejar que los futuros desarrolladores tengan un trabajo adicional de ingeniería inversa. Especialmente si te consideras "un novato" como en tu pregunta.

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

Cuidado con el [0] .

Es apropiado usar reducecomo enAntonio Laguna la respuesta.

Disculpas por la brevedad ...

Si su objeto es el mismo objeto que está utilizando dentro de la matriz, debería poder obtener el índice del objeto de la misma manera que lo haría como si fuera una cadena.

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

Prueba esto:

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

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

simple:

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

Si solo está interesado en encontrar el puesto, consulte la respuesta de @Pablo .

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

Sin embargo, si está ansioso por encontrar el elemento (es decir, si estaba pensando en hacer algo como esto myArray[pos]), hay una forma más eficiente de hacerlo en una línea , utilizando filter.

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

Ver resultados de rendimiento (~ + 42% ops / seg): http://jsbench.github.io/#7fa01f89a5dc5cc3bee79abfde80cdb3

Vea este ejemplo: http://jsfiddle.net/89C54/

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

Comienza a contar con cero.

Hice una función genérica para verificar que el siguiente es el código y funciona para cualquier objeto

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

La primera alerta devolverá -1 (significa coincidencia no encontrada) y la segunda alerta devolverá 0 (significa coincidencia encontrada).

Uso _.findIndexde la biblioteca underscore.js

Aquí está el ejemplo. _.findIndex([{a:1},{a: 2,c:10},{a: 3}], {a:2,c:10}) //1

Usando el findIndexmétodo ES6 , sin lodash ni ninguna otra biblioteca, puede escribir:

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

Esto comparará las propiedades inmediatas del objeto, pero no se repetirá en las propiedades.

Si su implementación aún no proporciona findIndex(la mayoría no), puede agregar un polyfill ligero que admita esta búsqueda:

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

(de mi respuesta en este engaño )

Puede utilizar una función nativa y conveniente Array.prototype.findIndex()básicamente:

El método findIndex () devuelve un índice en la matriz, si un elemento en la matriz satisface la función de prueba proporcionada. De lo contrario, se devuelve -1.

Solo una nota de que no es compatible con Internet Explorer, Opera y Safari, pero puede usar un Polyfill provisto en el siguiente enlace.

Más información:

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

Además de la respuesta de @Monika Garg , puedes usar findIndex()(Hay un polyfill para navegadores no soportados).

Vi que las personas rechazaron esta respuesta, y espero que lo hayan hecho debido a la sintaxis incorrecta, porque en mi opinión, esta es la forma más elegante.

El método findIndex () devuelve un índice en la matriz, si un elemento en la matriz satisface la función de prueba proporcionada. De lo contrario, se devuelve -1.

Por ejemplo:

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

Esta es la forma de encontrar el índice del objeto en la matriz

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

Esto funciona sin código personalizado

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

Nota: esto no proporciona el índice real, solo indica si su objeto existe en la estructura de datos actual

Simplemente puedes usar

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

Sin subrayado, no para, solo una reducción.

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

Puede crear su propio prototipo para hacer esto:

algo como:

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

Preferiré usar el findIndex()método:

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

index le dará el número de índice.