Como encontrar um valor em uma matriz de objetos em JavaScript?

Eu tenho uma série de objetos:

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

Eu quero ser capaz de pesquisar o objeto / matriz para onde a chave é "jantar" e ver se ela corresponde a "sushi".

Eu sei que o jQuery tem $ .inArray, mas não parece funcionar em matrizes de objetos. Ou talvez eu esteja errado. indexOf também parece funcionar apenas em um nível de array.

Não há função ou código existente para isso?

Se você tiver uma matriz como

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

Você pode usar o filtermétodo de um objeto Array:

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

Em implementações de JavaScript mais recentes, você pode usar uma expressão de função:

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

Você pode pesquisar por pessoas que "dinner": "sushi"usam ummap

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

ou um reduce

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

Tenho certeza que você é capaz de generalizar isso para chaves e valores arbitrários!

jQuery tem um método embutido jQuery.grepque funciona de forma semelhante à filterfunção ES5 da resposta de @adamse e deve funcionar bem em navegadores mais antigos.

Usando o exemplo de adamse:

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

você pode fazer o seguinte

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 .

Contanto que -1nunca seja uma chave válida.

Se você vai fazer essa pesquisa com frequência, considere alterar o formato do seu objeto para que o jantar seja realmente uma chave. Isso é como atribuir uma chave primária de cluster em uma tabela de banco de dados. Então, por exemplo:

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

Agora você pode acessá-lo facilmente assim: Object['sushi']['name']

Ou se o objeto é realmente tão simples (apenas 'nome' no objeto), você pode apenas alterá-lo para:

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

E então acessá-lo como: Object['sushi'].

Obviamente, nem sempre é possível ou vantajoso reestruturar seu objeto de dados dessa maneira, mas a questão é que, às vezes, a melhor resposta é considerar se seu objeto de dados está estruturado da melhor maneira. Criar uma chave como essa pode ser mais rápido e criar um código mais limpo.

Você pode encontrar o objeto na matriz com a 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]);

Experimente este exemplo em jsFiddle .

Você pode usar um loop for simples:

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

O exemplo de violino a seguir coloca todos os objetos que contêm dinner:sushiem uma matriz:

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

Já existem muitas respostas boas aqui, então por que não mais uma, use uma biblioteca como lodash ou sublinhado :)

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

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

Tive que pesquisar uma estrutura de mapa de site aninhada para o primeiro item folha que maquina um determinado caminho. Eu vim com o código a seguir usando apenas .map() .filter()e .reduce. Retorna o último item encontrado que corresponda ao caminho /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);

Eu tentaria não reinventar a roda. Usamos a varredura de objetos para todas as nossas necessidades de processamento de dados. É conceitualmente muito simples, mas permite muitas coisas legais. Aqui está como você resolveria sua questão específica

Definição de Dados

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

Lógica

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

const scanner = (input) => {
  let obj = null;
  objectScan(['*.dinner'], {
    filterFn: (key, value, { parents }) => {
      if (value === 'sushi') {
        obj = parents[0];
      }
    },
    breakFn: () => obj !== null
  })(data);
  return obj;
};

const result = scanner(data);

Resultado

// => result
{
  "name": "john",
  "dinner": "sushi"
}

Se você quiser encontrar um objeto específico por meio da função de pesquisa, tente algo assim:

    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 é um exemplo de objeto:

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

O código irá iterar e encontrar o array "usuário" e procurar o objeto que você procura dentro.

Meu problema era quando o índice da matriz mudava a cada atualização da janela e estava na terceira ou na segunda matriz, mas isso não importa.

Caiu como uma luva para mim!

No seu exemplo, é um pouco mais curto:

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