JavaScript : Comment filtrer le tableau d’objets basée sur des attributs ?

Question

J'ai le code JavaScript suivant tableau JSON de l'immobilier objets à la maison:

var json = { 'homes' : 
[
    {
        "home_id":"1",
        "price":"925",
        "sqft":"1100",
        "num_of_beds":"2",
        "num_of_baths":"2.0",
    },
    {
        "home_id":"2",
        "price":"1425",
        "sqft":"1900",
        "num_of_beds":"4",
        "num_of_baths":"2.5",
    },
    // ... (more homes) ...     
]}
var xmlhttp = eval('(' + json + ')');
homes = xmlhttp.homes;

Ce que je voudrais faire est d'être en mesure d'effectuer un filtre sur l'objet à retourner un sous-ensemble de la "maison" des objets.

Par exemple, je veux être en mesure de filtre basé sur: price, sqft, num_of_beds, et num_of_baths.

Question: Comment puis-je faire quelque chose en javascript, comme le pseudo-code ci-dessous:

var newArray = homes.filter(
price <= 1000 & 
sqft >= 500 & 
num_of_beds >=2 & 
num_of_baths >= 2.5);

Remarque, la syntaxe n'a pas à être exactement comme ci-dessus. C'est juste un exemple.

Answer 1

Vous pouvez utiliser la méthode Array.prototype.filter :

 homes.filter(function (el) {
  return el.price <= 1000 &&
         el.sqft >= 500 &&
         el.num_of_beds >=2 &&
         el.num_of_baths >= 2.5;
});
 

Cette méthode fait partie de la nouvelle norme ECMAScript 5th Edition et peut être trouvée sur presque tous les navigateurs modernes.

Pour IE, vous pouvez inclure la méthode suivante pour la compatibilité:

 if (!Array.prototype.filter) {
  Array.prototype.filter = function(fun /*, thisp*/) {
    var len = this.length >>> 0;
    if (typeof fun != "function")
    throw new TypeError();

    var res = [];
    var thisp = arguments[1];
    for (var i = 0; i < len; i++) {
      if (i in this) {
        var val = this[i]; // in case fun mutates this
        if (fun.call(thisp, val, i, this))
        res.push(val);
      }
    }
    return res;
  };
}
 

Answer 2

Vous pouvez essayer d'utiliser un framework comme jLinq - following est un exemple de code d'utilisation de jLinq

 var results = jLinq.from(data.users)
.startsWith("first", "a")
.orEndsWith("y")
.orderBy("admin", "age")
.select();
 

Pour plus d'informations, vous pouvez suivre le lien http://www.hugoware.net/projects/jlinq

Answer 3

Je préfère le cadre Underscore. Il suggère de nombreuses opérations utiles avec des objets. Ta tâche:

 var newArray = homes.filter(
    price <= 1000 & 
    sqft >= 500 &
    num_of_beds >=2 & 
    num_of_baths >= 2.5);
 

peut être écrasé comme:

 var newArray = _.filter (homes, function(home) {
    return home.price<=1000 && sqft>=500 && num_of_beds>=2 && num_of_baths>=2.5;
});
 

J'espère que cela vous sera utile!

Answer 4

voici le violon de travail qui fonctionne bien dans IE8 en utilisant la fonction jquery MAP

http://jsfiddle.net/533135/Cj4j7/

                 //code for filtering//
                json.HOMES =$.map(json.HOMES,function(val,key){
if(Number(val.price) <= 1000 && Number(val.sqft) >= 500&&Number(val.num_of_beds) >=2  && Number(val.num_of_baths )>= 2.5) return val;
            });

//code for filtering//
 

Answer 5

Vous pouvez le faire assez facilement - il y a probablement de nombreuses implémentations, vous pouvez choisir, mais c'est mon idée à la base (et il y a probablement un format où vous pouvez effectuer une itération sur un objet avec jQuery, j'ai juste ne peux pas penser à ça maintenant):

function filter(collection, predicate)
{
    var result = new Array();
    int length = collection.length;

    for(var j = 0; j < length; j++)
    {
        if(predicate(collection[j]) == true)
        {
             result.push(collection[j]);
        }
    }

    return result;
}

Et puis vous pouvez appeler cette fonction comme suit:

filter(json, function(element)
{
    if(element.price <= 1000 && element.sqft >= 500 && element.num_of_beds > 2 && element.num_of_baths > 2.5)
        return true;

    return false;
});

De cette façon, vous pouvez appeler le filtre, quel qu'en soit le prédicat de vous définir, ou même filtre plusieurs fois à l'aide de petits filtres.