matrice di oggetti del filtro javascript

Ho una serie di oggetti e mi chiedo il modo migliore per cercarli. Dato l'esempio seguente, come posso cercare name = "Joe"e age < 30? C'è qualcosa in cui jQuery può aiutare o devo forzare questa ricerca da solo?

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

Puoi usare jQuery.grep():

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

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

Puoi farlo molto facilmente con il [].filtermetodo:

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

Sarà necessario aggiungere uno shim per i browser che non supportano il [].filtermetodo: questa pagina MDN fornisce tale codice.

È possibile utilizzare la funzione jQuery.filter () per restituire elementi da un sottoinsieme di elementi corrispondenti.

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

Puoi semplicemente usare javascript :)

Per coloro che desiderano filtrare da un array di oggetti utilizzando qualsiasi chiave:

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

filtro da un array di oggetti JSON: **

Domanda così veloce. Cosa succede se si hanno due array di oggetti e si desidera "allineare" questi array di oggetti in modo da poter assicurarsi che gli oggetti di ogni array siano nell'ordine dell'altro array? E se non sapessi quali chiavi e valori contengono gli oggetti all'interno degli array ... e ancor meno in quale ordine si trovano?

Quindi è necessario un 'espressione jolly' per il vostro [].filter, [].mapecc Come si ottiene un espressione wild card?

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

Puoi anche utilizzare questa funzione su un'iterazione per ogni oggetto per creare un'espressione collettiva migliore per tutte le chiavi in ​​ciascuno dei tuoi oggetti, quindi filtrare l'array in questo modo.

Questo è un piccolo frammento dell'API Juxtapose che ho quasi completo, che fa questo, uguaglianza degli oggetti con esenzioni, unità di oggetti e condensazione di array. Se queste sono cose di cui hai bisogno o desideri per il tuo progetto, ti preghiamo di commentare e renderò la libreria accessibile il prima possibile.

Spero che sia di aiuto! Buona codifica :)

L'approccio più semplice e leggibile sarà l'utilizzo del metodo di filtro javascript nativo.

Il filtro javaScript nativo adotta un approccio dichiarativo nel filtrare gli elementi dell'array. Poiché si tratta di un metodo definito su Array.prototype, itera su un array fornito e invoca un callback su di esso. Questo callback, che funge da nostra funzione di filtro, accetta tre parametri:

element - l'elemento corrente nell'array su cui si sta iterando

index - l'indice o la posizione dell'elemento corrente nell'array su cui si sta iterando

array- l'array originale su cui è stato applicato il metodo di filtro Usiamo questo metodo di filtro in un esempio. Notare che il filtro può essere applicato su qualsiasi tipo di array. In questo esempio, filtreremo un array di oggetti in base a una proprietà dell'oggetto.

Un esempio di filtraggio di un array di oggetti in base alle proprietà degli oggetti potrebbe essere simile a questo:

// 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']

Per saperne di più sul filtraggio degli array nelle funzioni e per creare il tuo filtro, consulta questo articolo: https://medium.com/better-programming/build-your-own-filter-e88ba0dcbfae