¿Cómo obtener el índice del objeto por su propiedad en JavaScript?

Por ejemplo, tengo:

var Data = [
  { id_list: 1, name: 'Nick', token: '312312' },
  { id_list: 2, name: 'John', token: '123123' },
]

Entonces, quiero ordenar / invertir este objeto name, por ejemplo. Y luego quiero obtener algo como esto:

var Data = [
  { id_list: 2, name: 'John', token: '123123' },
  { id_list: 1, name: 'Nick', token: '312312' },
]

Y ahora quiero saber el índice del objeto con propiedad name='John'para obtener el valor del token de propiedad.

¿Cómo resuelvo el problema?

Como sugieren las otras respuestas, recorrer la matriz es probablemente la mejor manera. Pero lo pondría en su propia función y lo haría un poco más abstracto:

function findWithAttr(array, attr, value) {
    for(var i = 0; i < array.length; i += 1) {
        if(array[i][attr] === value) {
            return i;
        }
    }
    return -1;
}

var Data = [
    {id_list: 2, name: 'John', token: '123123'},
    {id_list: 1, name: 'Nick', token: '312312'}
];

Con esto, no solo puede encontrar cuál contiene 'John' sino que también puede encontrar cuál contiene el token '312312':

findWithAttr(Data, 'name', 'John'); // returns 0
findWithAttr(Data, 'token', '312312'); // returns 1
findWithAttr(Data, 'id_list', '10'); // returns -1

EDITAR: Función actualizada para devolver -1 cuando no se encuentra, por lo que sigue la misma construcción que Array.prototype.indexOf ()

Dado que la parte de clasificación ya está respondida. Solo voy a proponer otra forma elegante de obtener el índice de una propiedad en su matriz

Tu ejemplo es:

var Data = [
    {id_list:1, name:'Nick',token:'312312'},
    {id_list:2,name:'John',token:'123123'}
]

Tu puedes hacer:

var index = Data.map(function(e) { return e.name; }).indexOf('Nick');

Array.prototype.mapno está disponible en IE7 o IE8. Compatibilidad con ES5

Y aquí está con ES6 y sintaxis de flecha, que es aún más simple:

const index = Data.map(e => e.name).indexOf('Nick');

Si estás de acuerdo con el uso de ES6. Las matrices ahora tienen la función findIndex . Lo que significa que puedes hacer algo como esto:

const index = Data.findIndex(item => item.name === 'John');

var index = Data.findIndex(item => item.name == "John")

Cuál es una versión simplificada de:

var index = Data.findIndex(function(item){ return item.name == "John"})

Desde mozilla.org:

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

Si tiene problemas con IE, puede usar la función map () que es compatible desde 9.0 en adelante:

var index = Data.map(item => item.name).indexOf("Nick");

La única forma conocida para mí es recorrer toda la matriz:

var index=-1;
for(var i=0;i<Data.length;i++)
  if(Data[i].name==="John"){index=i;break;}

o mayúsculas y minúsculas:

var index=-1;
for(var i=0;i<Data.length;i++)
  if(Data[i].name.toLowerCase()==="john"){index=i;break;}

En el resultado, el índice variable contiene el índice del objeto o -1 si no se encuentra.

una forma prototípica

(function(){
  if (!Array.prototype.indexOfPropertyValue){
    Array.prototype.indexOfPropertyValue = function(prop,value){
      for (var index = 0; index < this.length; index++){
        if (this[index][prop]){
          if (this[index][prop] == value){
            return index;
          }
        }
      }
      return -1;
    }
  }
 })();
 // usage:
 var Data = [
 {id_list:1, name:'Nick',token:'312312'},{id_list:2,name:'John',token:'123123'}];
 Data.indexOfPropertyValue('name','John'); // returns 1 (index of array);
 Data.indexOfPropertyValue('name','Invalid name') // returns -1 (no result);
 var indexOfArray = Data.indexOfPropertyValue('name','John');
 Data[indexOfArray] // returns desired object.

Puede usar Array.sort usando una función personalizada como parámetro para definir su mecanismo de clasificación.

En su ejemplo, daría:

var Data = [
    {id_list:1, name:'Nick',token:'312312'},{id_list:2,name:'John',token:'123123'}
]

Data.sort(function(a, b){
    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
});

alert("First name is : " + Data[0].name); // alerts 'John'
alert("Second name is : " + Data[1].name); // alerts 'Nick'

La función de clasificación debe devolver -1 si a debe venir antes que b, 1 si a debe venir después de b y 0 si ambos son iguales. Depende de usted definir la lógica correcta en su función de clasificación para ordenar la matriz.

Editar: se perdió la última parte de su pregunta donde desea conocer el índice. Tendría que recorrer la matriz para encontrar eso como otros han dicho.

Simplemente revise su matriz y encuentre la posición:

var i = 0;
for(var item in Data) {
    if(Data[item].name == 'John')
        break;
    i++;
}
alert(i);

Esto puede ser útil.

function showProps(obj, objName) {  
  var result = "";  
  for (var i in obj)  
    result += objName + "." + i + " = " + obj[i] + "\n";  
  return result;  
}

Copié esto de https://developer.mozilla.org/en/JavaScript/Guide/Working_with_Objects

¿Por qué no usas una pequeña solución?

Cree una nueva matriz con nombres como índices. después de eso, todas las búsquedas usarán índices. Entonces, solo un bucle. ¡Después de eso no necesitas recorrer todos los elementos!

var Data = [
    {id_list:1, name:'Nick',token:'312312'},{id_list:2,name:'John',token:'123123'}
    ]
var searchArr = []
Data.forEach(function(one){
  searchArr[one.name]=one;
})
console.log(searchArr['Nick'])

http://jsbin.com/xibala/1/edit

ejemplo en vivo

Respuesta extendida de Chris Pickett porque en mi caso necesitaba buscar más profundo que un nivel de atributo:

function findWithAttr(array, attr, value) {
  if (attr.indexOf('.') >= 0) {
    var split = attr.split('.');
    var attr1 = split[0];
    var attr2 = split[1];
    for(var i = 0; i < array.length; i += 1) {
      if(array[i][attr1][attr2] === value) {
        return i;
      }
    }
  } else {
    for(var i = 0; i < array.length; i += 1) {
      if(array[i][attr] === value) {
        return i;
      }
    }
  };
};

Puede pasar 'attr1.attr2' a la función

¿Qué hay de esto? :

Data.indexOf(_.find(Data, function(element) {
  return element.name === 'John';
}));

Suponiendo que esté usando lodash o underscorejs.

var fields = {
teste:
{
    Acess:
    {
        Edit: true,
      View: false

      }
 },
teste1:
{
    Acess:
    {
        Edit: false,
      View: false

      }
  }
};

console.log(find(fields,'teste'));
function find(fields,field){
    for(key in fields){
        if(key == field){
        return true;
    }
}
return false;
}

Si tiene un objeto con objetos múltiples, si desea saber si algún objeto está incluido en el objeto maestro, simplemente coloque find (MasterObject, 'Object to Search'), esta función devolverá la respuesta si existe o no (VERDADERO o FALSO ), Espero ayuda con esto, puede ver el ejemplo en JSFiddle .

let indexOf = -1;
let theProperty = "value"
let searchFor = "something";

theArray.every(function (element, index) {

    if (element[theProperty] === searchFor) {
        indexOf = index;
        return false;
    }
    return true;
});

collection.findIndex(item => item.value === 'smth') !== -1

Si desea obtener el valor del token de propiedad, también puede probar esto

    let data=[
      { id_list: 1, name: 'Nick', token: '312312' },
      { id_list: 2, name: 'John', token: '123123' },
    ]

    let resultingToken =  data[_.findKey(data,['name','John'])].token

donde _.findKey es una función de lodash

Alternativamente a la respuesta de German Attanasio Ruiz, puede eliminar el segundo bucle utilizando Array.reduce () en lugar de Array.map ();

var Data = [
    { name: 'hypno7oad' }
]
var indexOfTarget = Data.reduce(function (indexOfTarget, element, currentIndex) {
    return (element.name === 'hypno7oad') ? currentIndex : indexOfTarget;
}, -1);

Usando guión bajo:

var index = _.indexOf(_.pluck(item , 'name'), 'Nick');