Como obter o índice do objeto por sua propriedade em JavaScript?

Por exemplo, eu tenho:

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

Então, quero classificar / reverter esse objeto name, por exemplo. E então eu quero obter algo parecido com isto:

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

E agora eu quero saber o índice do objeto com propriedade name='John'para obter o valor do token de propriedade.

Como resolvo o problema?

Como as outras respostas sugerem, fazer um loop pela matriz é provavelmente a melhor maneira. Mas eu colocaria isso em sua própria função e o tornaria um pouco mais abstrato:

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

Com isso, você não apenas pode encontrar qual deles contém 'John', mas também qual deles contém o token '312312':

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

EDIT: Função atualizada para retornar -1 quando não encontrado, para que siga a mesma construção que Array.prototype.indexOf ()

Uma vez que a parte de classificação já está respondida. Vou apenas propor outra maneira elegante de obter o indexOf de uma propriedade em sua matriz

Seu exemplo é:

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

Você pode fazer:

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

Array.prototype.mapnão está disponível no IE7 ou IE8. Compatibilidade com ES5

E aqui está o ES6 e a sintaxe da seta, que é ainda mais simples:

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

Se você está bem em usar o ES6. As matrizes agora têm a função findIndex . O que significa que você pode fazer algo assim:

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

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

Qual é uma versão simplificada de:

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

Em mozilla.org:

O método findIndex () retorna o índice do primeiro elemento na matriz que satisfaz a função de teste fornecida. Caso contrário, -1 será retornado.

Se você estiver tendo problemas com o IE, poderá usar a função map () que é suportada a partir do 9.0:

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

A única maneira conhecida por mim é percorrer toda a matriz:

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

ou não diferencia maiúsculas de minúsculas:

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

No resultado, o índice variável contém o índice do objeto ou -1 se não for encontrado.

uma maneira 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.

Você pode usar Array.sort usando uma função personalizada como parâmetro para definir seu mecanismo de classificação.

No seu exemplo, daria:

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'

A função de classificação deve retornar -1 se a vier antes de b, 1 se a vir depois de be 0 se ambos forem iguais. Cabe a você definir a lógica correta em sua função de classificação para classificar a matriz.

Editar: perdeu a última parte da sua pergunta em que você deseja conhecer o índice. Você teria que percorrer a matriz para descobrir isso, como outros disseram.

Basta percorrer sua matriz e encontrar a posição:

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

Isso pode ser útil

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

Copiou isso de https://developer.mozilla.org/en/JavaScript/Guide/Working_with_Objects

Por que você não usa uma pequena solução alternativa?

Crie uma nova matriz com nomes como índices. depois disso, todas as pesquisas usarão índices. Então, apenas um loop. Depois disso, você não precisa percorrer todos os 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

exemplo ao vivo.

Resposta estendida de Chris Pickett, porque no meu caso eu precisava pesquisar mais do que um nível 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;
      }
    }
  };
};

Você pode passar 'attr1.attr2' para a função

Que tal isso? :

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

Supondo que você esteja usando lodash ou 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;
}

Se você tiver um Objeto com objetos de multiplicação, se quiser saber se algum objeto está incluído no objeto Mestre, basta colocar find (MasterObject, 'Objeto a Pesquisar'), essa função retornará a resposta se existir ou não (TRUE ou FALSE ), Espero que ajude com isso, veja o exemplo no 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

Se você deseja obter o valor do token de propriedade, também pode tentar isso

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

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

onde _.findKey é uma função do lodash

Como alternativa à resposta do alemão Attanasio Ruiz, você pode eliminar o segundo loop usando Array.reduce () em vez de Array.map ();

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

Usando sublinhado:

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