Come ottenere l'indice dell'oggetto dalla sua proprietà in JavaScript?

Ad esempio, ho:

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

Quindi, voglio ordinare / invertire questo oggetto name, ad esempio. E poi voglio ottenere qualcosa del genere:

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

E ora voglio conoscere l'indice dell'oggetto con proprietà name='John'per ottenere il valore del token proprietà.

Come risolvo il problema?

Come suggeriscono le altre risposte, il looping dell'array è probabilmente il modo migliore. Ma lo metterei nella sua funzione e lo renderei un po 'più astratto:

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 questo, non solo puoi trovare quale contiene 'John' ma puoi trovare quale contiene il token '312312':

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

EDIT: funzione aggiornata per restituire -1 quando non trovato, quindi segue lo stesso costrutto di Array.prototype.indexOf ()

Poiché la parte di ordinamento ha già ricevuto risposta. Proporrò solo un altro modo elegante per ottenere l'indice di una proprietà nel tuo array

Il tuo esempio è:

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

Tu puoi fare:

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

Array.prototype.mapnon è disponibile su IE7 o IE8. Compatibilità ES5

Ed eccolo qui con ES6 e la sintassi della freccia, che è ancora più semplice:

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

Se stai bene usando ES6. Gli array ora hanno la funzione findIndex . Ciò significa che puoi fare qualcosa del genere:

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

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

Che è una versione semplificata di:

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

Da mozilla.org:

Il metodo findIndex () restituisce l'indice del primo elemento dell'array che soddisfa la funzione di test fornita. Altrimenti viene restituito -1.

Se riscontri problemi con IE, puoi utilizzare la funzione map () che è supportata dalla 9.0 in poi:

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

L'unico modo per me noto è quello di eseguire il looping di tutti gli array:

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

o maiuscole / minuscole:

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

Al risultato, l' indice variabile contiene l'indice dell'oggetto o -1 se non trovato.

un modo prototipico

(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.

È possibile utilizzare Array.sort utilizzando una funzione personalizzata come parametro per definire il meccanismo di ordinamento.

Nel tuo esempio, darebbe:

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 funzione di ordinamento deve restituire -1 se a deve precedere b, 1 se a deve venire dopo be 0 se entrambi sono uguali. Sta a te definire la logica giusta nella tua funzione di ordinamento per ordinare l'array.

Modifica: manca l'ultima parte della domanda in cui si desidera conoscere l'indice. Dovresti passare in rassegna l'array per scoprirlo come altri hanno già detto.

Basta passare attraverso l'array e trovare la posizione:

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

Questo potrebbe essere utile

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

Copiato da https://developer.mozilla.org/en/JavaScript/Guide/Working_with_Objects

Perché non usi una piccola soluzione?

Crea un nuovo array con nomi come indici. dopodiché tutte le ricerche utilizzeranno gli indici. Quindi, solo un loop. Dopodiché non è necessario passare in rassegna tutti gli elementi!

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

esempio dal vivo.

Estesa la risposta di Chris Pickett perché nel mio caso avevo bisogno di cercare più in profondità di un livello di attributo:

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

È possibile passare 'attr1.attr2' nella funzione

Che dire di questo ? :

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

Supponendo che tu stia 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;
}

Se hai un oggetto con moltiplicare gli oggetti all'interno, se vuoi sapere se alcuni oggetti sono inclusi nell'oggetto Master, basta mettere find (MasterObject, 'Object to Search'), questa funzione restituirà la risposta se esiste o no (TRUE o FALSE ), Spero di esserti di aiuto, posso vedere l'esempio su 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 si desidera ottenere il valore del token di proprietà, è possibile provare anche questo

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

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

dove _.findKey è la funzione di lodash

In alternativa alla risposta tedesca di Attanasio Ruiz, puoi eliminare il 2o ciclo usando Array.reduce () invece di Array.map ();

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

Utilizzando il trattino basso:

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