Tengo una matriz:

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

No puedo cambiar la estructura de la matriz. Me está pasando un id de 45, y quiero obtener 'bar'ese objeto en la matriz.

¿Cómo hago esto en JavaScript o usando jQuery?

Usa el find()método:

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

De MDN :

El find()método devuelve el primer valor en la matriz, si un elemento en la matriz satisface la función de prueba proporcionada. De undefinedlo contrario se devuelve.

Si quiere encontrar su índice , use findIndex():

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

De MDN :

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

Si desea obtener una matriz de elementos coincidentes, utilice el filter()método en su lugar:

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

Esto devolverá una matriz de objetos. Si desea obtener una matriz de foopropiedades, puede hacerlo con el map()método:

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

Nota al margen: métodos como find()o filter(), y las funciones de flecha no son compatibles con navegadores antiguos (como IE), por lo que si desea admitir estos navegadores, debe transpilar su código usando Babel (con el polyfill ).

Como ya está usando jQuery, puede usar la función grep que está diseñada para buscar una matriz:

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

El resultado es una matriz con los elementos encontrados. Si sabe que el objeto siempre está ahí y que solo ocurre una vez, puede usarlo result[0].foopara obtener el valor. De lo contrario, debe verificar la longitud de la matriz resultante. Ejemplo:

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
}

Otra solución es crear un objeto de búsqueda:

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

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

Esto es especialmente interesante si necesita hacer muchas búsquedas.

Esto no necesitará mucha más memoria ya que las ID y los objetos serán compartidos.

ECMAScript 2015 proporciona el método find () en matrices:

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

Funciona sin bibliotecas externas. Pero si desea un soporte de navegador más antiguo , puede incluir este polyfill .

Underscore.js tiene un buen método para eso:

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

Creo que la forma más fácil sería la siguiente, pero no funcionará en Internet Explorer 8 (o anterior):

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

Intenta lo siguiente

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 versión genérica y más flexible de la función findById anterior:

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

Puede obtener esto fácilmente usando la función 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";

Ejemplo de trabajo: http://jsfiddle.net/hunter/Pxaua/

Puedes usar filtros,

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

get_my_obj = getById(73, myArray);

Si bien hay muchas respuestas correctas aquí, muchas de ellas no abordan el hecho de que esta es una operación innecesariamente costosa si se realiza más de una vez. En un caso extremo, esto podría ser la causa de problemas reales de rendimiento.

En el mundo real, si está procesando muchos elementos y el rendimiento es una preocupación, es mucho más rápido crear inicialmente una búsqueda:

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

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

luego puede obtener artículos en un tiempo fijo como este:

var bar = o[id];

También puede considerar usar un Mapa en lugar de un objeto como búsqueda: 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)
});

devuelve el elemento objeto si se encuentra, de lo contrario false

Si hace esto varias veces, puede configurar un Mapa (ES6):

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

Entonces simplemente puedes hacer:

map.get(27).foo

Así es como lo haría en JavaScript puro, de la manera más mínima que pueda pensar que funciona en ECMAScript 3 o posterior. Regresa tan pronto como se encuentre una coincidencia.

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'

Más genérico y corto

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

en su caso Ej. var element = findFromArray(myArray,'id',45)eso te dará todo el elemento.

Puedes probar Sugarjs desde http://sugarjs.com/ .

Tiene un método muy dulce en matrices, .find. Entonces puedes encontrar un elemento como este:

array.find( {id: 75} );

También puede pasarle un objeto con más propiedades para agregar otra "cláusula where".

Tenga en cuenta que Sugarjs extiende objetos nativos, y algunas personas consideran esto muy malvado ...

Sobre la base de la respuesta aceptada:

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

Recientemente, tengo que enfrentar la misma cosa en la que necesito buscar la cadena desde una gran matriz.

Después de buscar, encontré que será fácil de manejar con un código simple:

Código:

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

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

Iterar sobre cualquier elemento de la matriz. Por cada artículo que visite, verifique la identificación de ese artículo. Si es un partido, devuélvelo.

Si solo quieres el 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
}

Y lo mismo con los métodos de matriz de 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];
}

Mientras el navegador sea compatible con ECMA-262 , 5a edición (diciembre de 2009), esto debería funcionar, casi de una sola línea:

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

Puede hacer esto incluso en JavaScript puro utilizando la función integrada "filtro" para las matrices:

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

Así que ahora simplemente pase "id" en lugar de key"45" en lugar de value, y obtendrá el objeto completo que coincide con un id de 45. Entonces eso sería,

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

Utiliza la Array.prototype.filter()función.

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

FILTRAR

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

Podemos usar los métodos de 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 );
});

use la sintaxis ES6:

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

O utilice Lodash https://lodash.com/docs/4.17.10#filter , subrayado https://underscorejs.org/#filter

Realmente me gustó la respuesta proporcionada por Aaron Digulla, pero necesitaba mantener mi conjunto de objetos para poder repetirlo más tarde. Entonces lo modifiqué para

	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

Utilizar:

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

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

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

Debe devolver un objeto por id.

Esta solución también puede ser útil:

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

Lo hice así $.grepy si un objeto se descubre, la función devolverá el objeto, en lugar de una matriz.

A partir de la respuesta de aggaton , esto es en realidad una función que devuelve el elemento deseado (o nullsi no se encuentra), dado el arrayy una callbackfunción que devuelve un valor Truthy para el elemento "correcta":

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

Solo recuerda que esto no funciona de forma nativa en IE8-, ya que no es compatible some. Se puede proporcionar un polyfill, alternativamente, siempre existe el forciclo clásico :

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

En realidad es más rápido y más compacto. Pero si no desea reinventar la rueda, le sugiero que use una biblioteca de utilidades como guión bajo o lodash.

Más corto

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

Considere "axesOptions" como una matriz de objetos con un formato de objeto que es {: 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;
}