Ho un array:

myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}, etc.]

Non riesco a cambiare la struttura dell'array. Mi viene passato un ID di 45e voglio ottenere 'bar'quell'oggetto nella matrice.

Come posso fare questo in JavaScript o usando jQuery?

Usa il find()metodo:

myArray.find(x => x.id === '45').foo;

Da MDN :

Il find()metodo restituisce il primo valore nella matrice, se un elemento nella matrice soddisfa la funzione di test fornita. Altrimenti undefinedviene restituito.

Se invece vuoi trovare il suo indice , usa findIndex():

myArray.findIndex(x => x.id === '45');

Da MDN :

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

Se si desidera ottenere una matrice di elementi corrispondenti, utilizzare filter()invece il metodo:

myArray.filter(x => x.id === '45');

Ciò restituirà una matrice di oggetti. Se vuoi ottenere una matrice di fooproprietà, puoi farlo con il map()metodo:

myArray.filter(x => x.id === '45').map(x => x.foo);

Nota a margine: metodi come find()o filter()e le funzioni freccia non sono supportati dai browser più vecchi (come IE), quindi se si desidera supportare questi browser, è necessario transpilare il codice usando Babel (con il polyfill ).

Dato che stai già utilizzando jQuery, puoi utilizzare la funzione grep che è destinata alla ricerca di un array:

var result = $.grep(myArray, function(e){ return e.id == id; });

Il risultato è un array con gli elementi trovati. Se sai che l'oggetto è sempre lì e che si verifica solo una volta, puoi semplicemente usare result[0].fooper ottenere il valore. Altrimenti è necessario verificare la lunghezza dell'array risultante. Esempio:

if (result.length === 0) {
  // no result found
} else if (result.length === 1) {
  // property found, access the foo property using result[0].foo
} else {
  // multiple items found
}

Un'altra soluzione è quella di creare un oggetto di ricerca:

var lookup = {};
for (var i = 0, len = array.length; i < len; i++) {
    lookup[array[i].id] = array[i];
}

... now you can use lookup[id]...

Questo è particolarmente interessante se devi fare molte ricerche.

Ciò non richiederà molta più memoria poiché gli ID e gli oggetti saranno condivisi.

ECMAScript 2015 fornisce il metodo find () sugli array:

var myArray = [
 {id:1, name:"bob"},
 {id:2, name:"dan"},
 {id:3, name:"barb"},
]

// grab the Array item which matchs the id "2"
var item = myArray.find(item => item.id === 2);

// print
console.log(item.name);

Funziona senza librerie esterne. Ma se desideri un supporto per browser meno recente , potresti voler includere questo polyfill .

Underscore.js ha un buon metodo per questo:

myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'},etc.]
obj = _.find(myArray, function(obj) { return obj.id == '45' })

Penso che il modo più semplice sarebbe il seguente, ma non funzionerà su Internet Explorer 8 (o precedente):

var result = myArray.filter(function(v) {
    return v.id === '45'; // Filter out the appropriate one
})[0].foo; // Get result and access the foo property

Prova quanto segue

function findById(source, id) {
  for (var i = 0; i < source.length; i++) {
    if (source[i].id === id) {
      return source[i];
    }
  }
  throw "Couldn't find object with id: " + id;
}

myArray.filter(function(a){ return a.id == some_id_you_want })[0]

Una versione generica e più flessibile della funzione findById sopra:

// array = [{key:value},{key:value}]
function objectFindByKey(array, key, value) {
    for (var i = 0; i < array.length; i++) {
        if (array[i][key] === value) {
            return array[i];
        }
    }
    return null;
}

var array = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];
var result_obj = objectFindByKey(array, 'id', '45');

Puoi ottenerlo facilmente usando la funzione map () :

myArray = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];

var found = $.map(myArray, function(val) {
    return val.id == 45 ? val.foo : null;
});

//found[0] == "bar";

Esempio di lavoro: http://jsfiddle.net/hunter/Pxaua/

Puoi usare i filtri,

  function getById(id, myArray) {
    return myArray.filter(function(obj) {
      if(obj.id == id) {
        return obj 
      }
    })[0]
  }

get_my_obj = getById(73, myArray);

Sebbene ci siano molte risposte corrette qui, molte di esse non affrontano il fatto che si tratta di un'operazione inutilmente costosa se eseguita più di una volta. In un caso estremo questo potrebbe essere la causa di reali problemi di prestazioni.

Nel mondo reale, se stai elaborando molti elementi e le prestazioni sono una preoccupazione è molto più veloce inizialmente costruire una ricerca:

var items = [{'id':'73','foo':'bar'},{'id':'45','foo':'bar'}];

var lookup = items.reduce((o,i)=>o[i.id]=o,{});

puoi quindi ottenere gli articoli a tempo fisso come questo:

var bar = o[id];

Puoi anche considerare di utilizzare una mappa anziché un oggetto come ricerca: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Map

Usando nativo Array.reduce

var array = [ {'id':'73' ,'foo':'bar'} , {'id':'45' ,'foo':'bar'} , ];
var id = 73;

var found = array.reduce(function(a, b){
    return (a.id==id && a) || (b.id == id && b)
});

restituisce l'elemento object se trovato, altrimenti false

Se lo fai più volte, puoi impostare una mappa (ES6):

const map = new Map( myArray.map(el => [el.id, el]) );

Quindi puoi semplicemente fare:

map.get(27).foo

Ecco come lo farei in puro JavaScript, nel modo più minimale che riesco a pensare che funzioni in ECMAScript 3 o versioni successive. Ritorna non appena viene trovata una corrispondenza.

var getKeyValueById = function(array, key, id) {
    var testArray = array.slice(), test;
    while(test = testArray.pop()) {
        if (test.id === id) {
            return test[key];
        }
    }
    // return undefined if no matching id is found in array
    return;
}

var myArray = [{'id':'73', 'foo':'bar'}, {'id':'45', 'foo':'bar'}]
var result = getKeyValueById(myArray, 'foo', '45');

// result is 'bar', obtained from object with id of '45'

Più generico e breve

function findFromArray(array,key,value) {
        return array.filter(function (element) {
            return element[key] == value;
        }).shift();
}

nel tuo caso es. var element = findFromArray(myArray,'id',45)che ti darà l'intero elemento.

Puoi provare Sugarjs da http://sugarjs.com/ .

Ha un metodo molto dolce su Array, .find. Quindi puoi trovare un elemento come questo:

array.find( {id: 75} );

È inoltre possibile passare un oggetto con più proprietà ad esso per aggiungere un'altra "clausola where".

Nota che Sugarjs estende gli oggetti nativi e alcune persone lo considerano molto malvagio ...

Sulla base della risposta accettata:

jQuery:

var foo = $.grep(myArray, function(e){ return e.id === foo_id})
myArray.pop(foo)

O CoffeeScript:

foo = $.grep myArray, (e) -> e.id == foo_id
myArray.pop foo

Di recente, devo affrontare la stessa cosa in cui devo cercare la stringa da un array enorme.

Dopo alcune ricerche ho scoperto che sarà facile da gestire con un semplice codice:

Codice:

var items = mydata.filter(function(item){
    return item.word.toLowerCase().startsWith( 'gk );
})

Vedi https://jsfiddle.net/maheshwaghmare/cfx3p40v/4/

Scorrere su qualsiasi elemento dell'array. Per ogni oggetto che visiti, controlla l'ID dell'articolo. Se è una partita, restituiscila.

Se vuoi solo il codez:

function getId(array, id) {
    for (var i = 0, len = array.length; i < len; i++) {
        if (array[i].id === id) {
            return array[i];
        }
    }
    return null; // Nothing found
}

E la stessa cosa usando i metodi Array di ECMAScript 5:

function getId(array, id) {
    var obj = array.filter(function (val) {
        return val.id === id;
    });

    // Filter returns an array, and we just want the matching item.
    return obj[0];
}

Finché il browser supporta ECMA-262 , 5a edizione (dicembre 2009), questo dovrebbe funzionare, quasi una riga:

var bFound = myArray.some(function (obj) {
    return obj.id === 45;
});

Puoi farlo anche in puro JavaScript usando la funzione "filtro" incorporata per gli array:

Array.prototype.filterObjects = function(key, value) {
    return this.filter(function(x) { return x[key] === value; })
}

Quindi ora passa semplicemente "id" al posto di keye "45" al posto di value, e otterrai l'intero oggetto che corrisponde a un id di 45. Quindi sarebbe,

myArr.filterObjects("id", "45");

Usa la Array.prototype.filter()funzione.

DEMO : https://jsfiddle.net/sumitridhal/r0cz0w5o/4/

JSON

var jsonObj =[
 {
  "name": "Me",
  "info": {
   "age": "15",
   "favColor": "Green",
   "pets": true
  }
 },
 {
  "name": "Alex",
  "info": {
   "age": "16",
   "favColor": "orange",
   "pets": false
  }
 },
{
  "name": "Kyle",
  "info": {
   "age": "15",
   "favColor": "Blue",
   "pets": false
  }
 }
];

FILTRO

var getPerson = function(name){
    return jsonObj.filter(function(obj) {
      return obj.name === name;
    });
}

Possiamo usare i metodi Jquery $.each()/$.grep()

var data= [];
$.each(array,function(i){if(n !== 5 && i > 4){data.push(item)}}

o

var data = $.grep(array, function( n, i ) {
  return ( n !== 5 && i > 4 );
});

usa la sintassi ES6:

Array.find, Array.filter, Array.forEach, Array.map

Oppure usa Lodash https://lodash.com/docs/4.17.10#filter , Underscore https://underscorejs.org/#filter

Mi è piaciuta molto la risposta fornita da Aaron Digulla, ma avevo bisogno di mantenere la mia gamma di oggetti in modo da poterla scorrere più tardi. Quindi l'ho modificato in

	var indexer = {};
	for (var i = 0; i < array.length; i++) {
	    indexer[array[i].id] = parseInt(i);
	}
	
	//Then you can access object properties in your array using 
	array[indexer[id]].property

Uso:

var retObj ={};
$.each(ArrayOfObjects, function (index, obj) {

        if (obj.id === '5') { // id.toString() if it is int

            retObj = obj;
            return false;
        }
    });
return retObj;

Dovrebbe restituire un oggetto per ID.

Questa soluzione può essere utile anche:

Array.prototype.grep = function (key, value) {
    var that = this, ret = [];
    this.forEach(function (elem, index) {
        if (elem[key] === value) {
            ret.push(that[index]);
        }
    });
    return ret.length < 2 ? ret[0] : ret;
};
var bar = myArray.grep("id","45");

L'ho fatto proprio come $.grepe se un oggetto viene scoperto, la funzione restituirà l'oggetto, piuttosto che un array.

A partire dalla risposta di aggaton , questa è una funzione che restituisce effettivamente l'elemento desiderato (o nullse non trovato), data la arraye una callbackfunzione che restituisce un valore di verità per l'elemento "corretto":

function findElement(array, callback) {
    var elem;
    return array.some(function(e) {
        if (callback(e)) {
            elem = e;
            return true;
        }
    }) ? elem : null;
});

Ricorda solo che questo non funziona nativamente su IE8-, in quanto non supporta some. È possibile fornire un polyfill, in alternativa c'è sempre il classico forloop:

function findElement(array, callback) {
    for (var i = 0; i < array.length; i++)
        if (callback(array[i])) return array[i];
    return null;
});

In realtà è più veloce e più compatto. Ma se non vuoi reinventare la ruota, ti suggerisco di usare una libreria di utilità come underscore o lodash.

Più breve,

var theAnswerObj = _.findWhere(array, {id : 42});

Considera "axesOptions" come una matrice di oggetti con un formato oggetto {: field_type => 2,: fields => [1,3,4]}

function getFieldOptions(axesOptions,choice){
  var fields=[]
  axesOptions.each(function(item){
    if(item.field_type == choice)
        fields= hashToArray(item.fields)
  });
  return fields;
}