¿Cómo encontrar un valor en una matriz de objetos en JavaScript?

Tengo una variedad de objetos:

Object = {
   1 : { name : bob , dinner : pizza },
   2 : { name : john , dinner : sushi },
   3 : { name : larry, dinner : hummus }
}

Quiero poder buscar el objeto / matriz donde la clave es "cena" y ver si coincide con "sushi".

Sé que jQuery tiene $ .inArray, pero no parece funcionar en matrices de objetos. O tal vez me equivoque. indexOf también parece funcionar solo en un nivel de matriz.

¿No existe ninguna función o código para esto?

Si tiene una matriz como

var people = [
  { "name": "bob", "dinner": "pizza" },
  { "name": "john", "dinner": "sushi" },
  { "name": "larry", "dinner": "hummus" }
];

Puede utilizar el filtermétodo de un objeto Array:

people.filter(function (person) { return person.dinner == "sushi" });
  // => [{ "name": "john", "dinner": "sushi" }]

En implementaciones de JavaScript más recientes, puede usar una expresión de función:

people.filter(p => p.dinner == "sushi")
  // => [{ "name": "john", "dinner": "sushi" }]

Puede buscar personas que hayan "dinner": "sushi"utilizado unmap

people.map(function (person) {
  if (person.dinner == "sushi") {
    return person
  } else {
    return null
  }
}); // => [null, { "name": "john", "dinner": "sushi" }, null]

o un reduce

people.reduce(function (sushiPeople, person) {
  if (person.dinner == "sushi") {
    return sushiPeople.concat(person);
  } else {
    return sushiPeople
  }
}, []); // => [{ "name": "john", "dinner": "sushi" }]

¡Estoy seguro de que puede generalizar esto a claves y valores arbitrarios!

jQuery tiene un método incorporado jQuery.grepque funciona de manera similar a la filterfunción ES5 de la Respuesta de @ adamse y debería funcionar bien en navegadores más antiguos.

Usando el ejemplo de Adamse:

var peoples = [
  { "name": "bob", "dinner": "pizza" },
  { "name": "john", "dinner": "sushi" },
  { "name": "larry", "dinner": "hummus" }
];

puedes hacer lo siguiente

jQuery.grep(peoples, function (person) { return person.dinner == "sushi" });
  // => [{ "name": "john", "dinner": "sushi" }]

var getKeyByDinner = function(obj, dinner) {
    var returnKey = -1;

    $.each(obj, function(key, info) {
        if (info.dinner == dinner) {
           returnKey = key;
           return false; 
        };   
    });

    return returnKey;       

}

jsFiddle .

Siempre que -1nunca sea una clave válida.

Si va a realizar esta búsqueda con frecuencia, considere cambiar el formato de su objeto para que la cena sea la clave. Esto es como asignar una clave agrupada primaria en una tabla de base de datos. Así por ejemplo:

Obj = { 'pizza' : { 'name' : 'bob' }, 'sushi' : { 'name' : 'john' } }

Ahora puede acceder fácilmente a él de esta manera: Object['sushi']['name']

O si el objeto realmente es así de simple (solo 'nombre' en el objeto), puede cambiarlo a:

Obj = { 'pizza' : 'bob', 'sushi' : 'john' }

Y luego acceder a ella como: Object['sushi'].

Obviamente, no siempre es posible o ventajoso reestructurar su objeto de datos de esta manera, pero el punto es que, a veces, la mejor respuesta es considerar si su objeto de datos está estructurado de la mejor manera. Crear una clave como esta puede ser más rápido y crear un código más limpio.

Puede encontrar el objeto en una matriz con la biblioteca Alasql :

var data = [ { name : "bob" , dinner : "pizza" }, { name : "john" , dinner : "sushi" },
     { name : "larry", dinner : "hummus" } ];

var res = alasql('SELECT * FROM ? WHERE dinner="sushi"',[data]);

Pruebe este ejemplo en jsFiddle .

Puede usar un bucle for in simple:

for (prop in Obj){
    if (Obj[prop]['dinner'] === 'sushi'){

        // Do stuff with found object. E.g. put it into an array:
        arrFoo.push(Obj[prop]);
    }
}

El siguiente ejemplo de violín coloca todos los objetos que contienen dinner:sushien una matriz:

https://jsfiddle.net/3asvkLn6/1/

Ya hay muchas buenas respuestas aquí, así que ¿por qué no una más? Usa una biblioteca como lodash o subrayado :)

obj = {
   1 : { name : 'bob' , dinner : 'pizza' },
   2 : { name : 'john' , dinner : 'sushi' },
   3 : { name : 'larry', dinner : 'hummus' }
}

_.where(obj, {dinner: 'pizza'})
>> [{"name":"bob","dinner":"pizza"}]

Tuve que buscar una estructura de mapa de sitio anidada para el primer elemento de hoja que mapea una ruta determinada. Se me ocurrió el siguiente código simplemente usando .map() .filter()y .reduce. Devuelve el último elemento encontrado que coincide con la ruta /c.

var sitemap = {
  nodes: [
    {
      items: [{ path: "/a" }, { path: "/b" }]
    },
    {
      items: [{ path: "/c" }, { path: "/d" }]
    },
    {
      items: [{ path: "/c" }, { path: "/d" }]
    }
  ]
};

const item = sitemap.nodes
  .map(n => n.items.filter(i => i.path === "/c"))
  .reduce((last, now) => last.concat(now))
  .reduce((last, now) => now);

Si desea encontrar un objeto específico a través de la función de búsqueda, intente algo como esto:

    function findArray(value){

        let countLayer = dataLayer.length;
        for(var x = 0 ; x < countLayer ; x++){

            if(dataLayer[x].user){
                let newArr = dataLayer[x].user;
                let data = newArr[value];
                return data;
            }

        }

        return null;

    }

    findArray("id");

Este es un objeto de ejemplo:

layerObj = {
    0: { gtm.start :1232542, event: "gtm.js"},
    1: { event: "gtm.dom", gtm.uniqueEventId: 52},
    2: { visitor id: "abcdef2345"},
    3: { user: { id: "29857239", verified: "Null", user_profile: "Personal", billing_subscription: "True", partners_user: "adobe"}
}

El código iterará y encontrará la matriz "usuario" y buscará el objeto que busca en su interior.

Mi problema fue cuando el índice de la matriz cambiaba cada actualización de la ventana y estaba en la tercera o segunda matriz, pero no importa.

¡Funcionó como un encanto para mí!

En tu ejemplo es un poco más corto:

function findArray(value){

    let countLayer = Object.length;
    for(var x = 0 ; x < countLayer ; x++){

        if(Object[x].dinner === value){
            return Object[x];
        }

    }

    return null;

}

findArray('sushi');

Intentaría no reinventar la rueda. Utilizamos el escaneo de objetos para todas nuestras necesidades de procesamiento de datos. Es conceptualmente muy simple, pero permite muchas cosas interesantes. Así es como resolvería su pregunta específica

const objectScan = require('object-scan');

const findDinner = (dinner, data) => objectScan(['*'], {
  abort: true,
  rtn: 'value',
  filterFn: ({ value }) => value.dinner === dinner
})(data);

const data = {
  1: { name: 'bob', dinner: 'pizza' },
  2: { name: 'john', dinner: 'sushi' },
  3: { name: 'larry', dinner: 'hummus' }
};

console.log(findDinner('sushi', data));
// => { name: 'john', dinner: 'sushi' }