matriz de filtros de JavaScript de objetos

Tengo una variedad de objetos y me pregunto cuál es la mejor manera de buscarlos. Dado el siguiente ejemplo, ¿cómo puedo buscar name = "Joe"y age < 30? ¿Hay algo en lo que jQuery pueda ayudar o tengo que forzarme a hacer esta búsqueda yo mismo?

var names = new Array();

var object = { name : "Joe", age:20, email: "joe@hotmail.com"};
names.push(object);

object = { name : "Mike", age:50, email: "mike@hotmail.com"};
names.push(object);

object = { name : "Joe", age:45, email: "mike@hotmail.com"};
names.push(object);

Puede utilizar jQuery.grep():

var found_names = $.grep(names, function(v) {
    return v.name === "Joe" && v.age < 30;
});

DEMO: http://jsfiddle.net/ejPV4/

Puede hacer esto muy fácilmente con el [].filtermétodo:

var filterednames = names.filter(function(obj) {
    return (obj.name === "Joe") && (obj.age < 30);
});

Deberá agregar una corrección para los navegadores que no admiten el [].filtermétodo: esta página de MDN proporciona dicho código.

Puede utilizar la función jQuery.filter () para devolver elementos de un subconjunto de los elementos coincidentes.

var names = [
    { name : "Joe", age:20, email: "joe@hotmail.com"},
    { name : "Mike", age:50, email: "mike@hotmail.com"},
    { name : "Joe", age:45, email: "mike@hotmail.com"}
   ];
   
   
var filteredNames = $(names).filter(function( idx ) {
    return names[idx].name === "Joe" && names[idx].age < 30;
}); 

$(filteredNames).each(function(){
     $('#output').append(this.name);
});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<div id="output"/>

var nameList = [
{name:'x', age:20, email:'x@email.com'},
{name:'y', age:60, email:'y@email.com'},
{name:'Joe', age:22, email:'joe@email.com'},
{name:'Abc', age:40, email:'abc@email.com'}
];

var filteredValue = nameList.filter(function (item) {
      return item.name == "Joe" && item.age < 30;
});

//To See Output Result as Array
console.log(JSON.stringify(filteredValue));

Simplemente puede usar javascript :)

Para aquellos que quieran filtrar de una matriz de objetos usando cualquier clave:

function filterItems(items, searchVal) {
  return items.filter((item) => Object.values(item).includes(searchVal));
}
let data = [
  { "name": "apple", "type": "fruit", "id": 123234 },
  { "name": "cat", "type": "animal", "id": 98989 },
  { "name": "something", "type": "other", "id": 656565 }]


console.log("Filtered by name: ", filterItems(data, "apple"));
console.log("Filtered by type: ", filterItems(data, "animal"));
console.log("Filtered by id: ", filterItems(data, 656565));

filtrar de una matriz de los objetos JSON: **

Pregunta tan rápida. ¿Qué sucede si tiene dos matrices de objetos y le gustaría 'alinear' estas matrices de objetos para que pueda asegurarse de que los objetos de cada matriz estén en el orden de la otra matriz? ¿Qué pasa si no sabe qué claves y valores contiene alguno de los objetos dentro de las matrices ... y mucho menos en qué orden están?

Así que hay una 'Expresión comodín' para su [].filter, [].map, etc. ¿Cómo se obtiene una expresión comodín?

var jux = (function(){
    'use strict';

    function wildExp(obj){
        var keysCrude = Object.keys(obj),
            keysA = ('a["' + keysCrude.join('"], a["') + '"]').split(', '),
            keysB = ('b["' + keysCrude.join('"], b["') + '"]').split(', '),
            keys = [].concat(keysA, keysB)
                .sort(function(a, b){  return a.substring(1, a.length) > b.substring(1, b.length); });
        var exp = keys.join('').split(']b').join('] > b').split(']a').join('] || a');
        return exp;
    }

    return {
        sort: wildExp
    };

})();

var sortKeys = {
    k: 'v',
    key: 'val',
    n: 'p',
    name: 'param'
};
var objArray = [
    {
        k: 'z',
        key: 'g',
        n: 'a',
        name: 'b'
    },
    {
        k: 'y',
        key: 'h',
        n: 'b',
        name: 't'
    },
    {
        k: 'x',
        key: 'o',
        n: 'a',
        name: 'c'
    }
];
var exp = jux.sort(sortKeys);

console.log('@juxSort Expression:', exp);
console.log('@juxSort:', objArray.sort(function(a, b){
    return eval(exp);
}));

También puede usar esta función en una iteración para cada objeto para crear una mejor expresión colectiva para todas las claves en cada uno de sus objetos, y luego filtrar su matriz de esa manera.

Este es un pequeño fragmento de API Juxtapose que tengo casi completo, que hace esto, igualdad de objetos con exenciones, unidades de objetos y condensación de matrices. Si estas son cosas que necesita o desea para su proyecto, por favor comente y haré que la biblioteca sea accesible más temprano que tarde.

¡Espero que esto ayude! Feliz codificación :)

El enfoque más sencillo y legible será el uso del método de filtro nativo de JavaScript.

El filtro javaScript nativo adopta un enfoque declarativo para filtrar elementos de matriz. Dado que es un método definido en Array.prototype, itera en una matriz proporcionada e invoca una devolución de llamada en ella. Esta devolución de llamada, que actúa como nuestra función de filtrado, toma tres parámetros:

element - el elemento actual en la matriz que se itera

index - el índice o la ubicación del elemento actual en la matriz sobre la que se está iterando

array- la matriz original en la que se aplicó el método de filtro Usemos este método de filtro en un ejemplo. Tenga en cuenta que el filtro se puede aplicar a cualquier tipo de matriz. En este ejemplo, vamos a filtrar una matriz de objetos según la propiedad de un objeto.

Un ejemplo de filtrado de una matriz de objetos en función de las propiedades del objeto podría verse así:

// Please do not hate me for bashing on pizza and burgers.
// and FYI, I totally made up the healthMetric param :)
let foods = [
  { type: "pizza", healthMetric: 25 },
  { type: "burger", healthMetric: 10 },
  { type: "salad", healthMetric: 60 },
  { type: "apple", healthMetric: 82 }
];
let isHealthy = food => food.healthMetric >= 50;

const result = foods.filter(isHealthy);

console.log(result.map(food => food.type));
// Result: ['salad', 'apple']

Para obtener más información sobre el filtrado de matrices en funciones y crear su propio filtrado, consulte este artículo: https://medium.com/better-programming/build-your-own-filter-e88ba0dcbfae