Javascript 如何基于属性过滤对象数组？

我有以下房地产房屋对象的JavaScript数组：

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;

我想做的是能够对对象执行筛选，以返回“主”对象的子集

例如，我希望能够基于以下内容进行过滤：

price

，

sqft

，

num\u of_beds

，以及

num\u of_baths

如何在JavaScript中执行以下伪代码：

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

var newArray=homes.filter(
价格=500&
床位数>=2张
浴缸数量>=2.5）；

---

注意，语法不必与上面的完全相同。这只是一个例子。

你可以很容易地做到这一点-可能有很多实现可供选择，但这是我的基本想法（可能有一些格式可以使用jQuery迭代对象，我现在想不起来）：

函数过滤器（集合，谓词）
{
var result=新数组（）；
var length=collection.length；
对于（var j=0；j

然后你可以这样调用这个函数：

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

过滤器（json，函数（元素）
{
如果（element.price=500&&element.num_of_床>2&&element.num_of_浴>2.5）
返回true；
返回false；
});

这样，您可以根据定义的任何谓词调用过滤器，甚至可以使用较小的过滤器多次过滤

您可以使用以下方法：

var newArray=homes.filter（函数（el）{
返回el.price=500&&
床位数>=2&&
电解槽数>=2.5；
});

实例：

var obj={
“家”：[{
“家庭id”：“1”，
“价格”：“925”，
“sqft”：“1100”，
“床位数”：“2”，
“洗澡次数”：“2.0”，
}, {
“家庭id”：“2”，
“价格”：“1425”，
“sqft”：“1900”，
“床位数”：“4”，
“洗澡次数”：“2.5”，
},
//…（更多的房子）。。。
]
};
//（注意，由于'price'等在对象中以字符串形式给出，
//下面的公式依赖于=与字符串和数字的关系
//将在比较之前将字符串强制为数字。）
var newArray=obj.homes.filter（函数（el）{
返回el.price=500&&
床位数>=2&&
el.num_of_baths>=1.5；//更改了此选项，以便使家庭匹配
});
log（newArray）您可以尝试使用类似jLinq的框架-以下是使用jLinq的代码示例

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

有关更多信息，请点击链接
我更喜欢下划线框架。它建议对对象执行许多有用的操作。
您的任务：

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

var newArray=homes.filter(
价格=500&
床位数>=2张
浴缸数量>=2.5）；

可以像以下那样覆盖：

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

var newArray=\过滤器（homes，函数（home）{
回家吧。价格=500张床的数量>=2张浴室的数量>=2.5；
});

希望它对你有用
 以下是使用jquery映射函数在IE8中运行良好的工作小提琴


json.HOMES=$.map（json.HOMES，函数（val，key）{
如果（数量（价值价格）=500
&&床位数（床位数）>=2
&&数量（浴室的数值）>=2.5）
返回val；
});
您可以自己实现一种满足您需要的过滤方法，下面是如何实现的：

function myfilter(array, test){
    var passedTest =[];
    for (var i = 0; i < array.length; i++) {
       if(test( array[i]))
          passedTest.push(array[i]);
    }

    return passedTest;
}

var passedHomes = myfilter(homes,function(currentHome){
     return ((currentHome.price <= 1000 )&& (currentHome.sqft >= 500 )&&(currentHome.num_of_beds >=2 )&&(currentHome.num_of_baths >= 2.5));
});

函数myfilter（数组，测试）{
var passedTest=[]；
对于（var i=0；i=2）和&（currentHome.num_of_baths>=2.5））；
});

希望有帮助
 您可以使用jQuery.grep（），因为jQuery 1.0：

$.grep(homes, function (h) {
  return h.price <= 1000
    && h.sqft >= 500
    && h.num_of_beds >= 2
    && h.num_of_baths >= 2.5
});

$.grep（家庭，功能（h）{
返回h.price=500
&&h.床的数量>=2
&&h.num\u\u槽>=2.5
});
或者您可以简单地使用
$。每个
（也适用于对象，而不仅仅是数组）并构建一个新数组，如下所示：

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) ...     
        {
            "home_id": "3-will-be-matched",
            "price": "925",
            "sqft": "1000",
            "num_of_beds": "2",
            "num_of_baths": "2.5",
        },
    ]
}

var homes = [];
$.each(json.homes, function(){
    if (this.price <= 1000
        && this.sqft >= 500
        && this.num_of_beds >= 2
        && this.num_of_baths >= 2.5
    ) {
        homes.push(this);
    }
});

var json={
“家”：[{
“家庭id”：“1”，
“价格”：“925”，
“sqft”：“1100”，
“床位数”：“2”，
“洗澡次数”：“2.0”，
}, {
“家庭id”：“2”，
“价格”：“1425”，
“sqft”：“1900”，
“床位数”：“4”，
“洗澡次数”：“2.5”，
},
//…（更多的房子）。。。
{
“home_id”：“3-will-be-matched”，
“价格”：“925”，
“平方英尺”：“1000”，
“床位数”：“2”，
“洗澡次数”：“2.5”，
},
]
}
var homes=[]；
$.each（json.homes，function（）{
如果（这个价格=500
&&此.num床数>=2
&&这个.num\u的浴室>=2.5
) {
推（这个）；
}
});
您应该查看哪些内置了过滤方法并扩展了标准javascript数组（以及分组、排序和查找）。以下是它为过滤器支持的运算符列表：

'eq' //Equal to
'eqjson' //For deep objects, JSON comparison, equal to
'neq' //Not equal to
'in' //Contains
'nin' //Doesn't contain
'lt' //Lesser than
'lte' //Lesser or equal to
'gt' //Greater than
'gte' //Greater or equal to
'btw' //Between, expects value to be array [_from_, _to_]
'substr' //Substring mode, equal to, expects value to be array [_from_, _to_, _niddle_]
'regex' //Regex match

你可以这样使用它

  let list = new OGX.List(your_array);
  list.addFilter('price', 'btw', 100, 500);
  list.addFilter('sqft', 'gte', 500);
  let filtered_list = list.filter();

甚至是这样

  let list = new OGX.List(your_array);
  let filtered_list = list.get({price:{btw:[100,500]}, sqft:{gte:500}});

还是作为一个班轮

   let filtered_list = new OGX.List(your_array).get({price:{btw:[100,500]}, sqft:{gte:500}});

var filterHome=homes.filter（home=>
返回（home.price=2.5）&&
home.num床数>=2&&
home.sqft>=998）；
控制台日志（过滤室）；

您可以使用这个lambda函数。更多细节可以在这里找到，因为我们根据返回true或false的条件过滤数据，它将收集不同数组中的数据，因此不会修改实际数组

@JGreig请调查一下。
我很惊讶没有人发布一行回复：

const filteredHomes = json.homes.filter(x => x.price <= 1000 && x.sqft >= 500 && x.num_of_beds >=2 && x.num_of_baths >= 2.5);

const filteredHomes=json.homes.filter（x=>x.price=500&&x.num\u床>=2&&x.num\u浴>=2.5）；

…这样你就可以看了
  let list = new OGX.List(your_array);
  let filtered_list = list.get({price:{btw:[100,500]}, sqft:{gte:500}});

   let filtered_list = new OGX.List(your_array).get({price:{btw:[100,500]}, sqft:{gte:500}});

var filterHome = homes.filter(home =>
  return (home.price <= 999 &&
         home.num_of_baths >= 2.5 &&
         home.num_of_beds >=2 &&
         home.sqft >= 998));
console.log(filterHome);

const filteredHomes = json.homes.filter(x => x.price <= 1000 && x.sqft >= 500 && x.num_of_beds >=2 && x.num_of_baths >= 2.5);

const filteredHomes = json.homes.filter( x => 
  x.price <= 1000 && 
  x.sqft >= 500 && 
  x.num_of_beds >=2 && 
  x.num_of_baths >= 2.5
);

const x = JSON.stringify(data);
const y = 'search text';

const data = x.filter(res => {
        return(JSON.stringify(res).toLocaleLowerCase()).match(x.toLocaleLowerCase());
      });

function ruleOut(arr, filterObj, applyAllFilters=true) {    
    return arr.filter( row => {            
        for (var field in filterObj) {
            var val = row[field];
            if (val) {                    
                if (applyAllFilters && filterObj[field].indexOf(val) > -1) return false;                
                else if (!applyAllFilters) {                        
                    return filterObj[field].filter(function(filterValue){ 
                        return (val.indexOf(filterValue)>-1);
                    }).length == 0;                 
                }
            }
        }
        return true;
    });
}

let actors = [
  {userName:"Mary", job:"star", language:"Turkish"},
  {userName:"John", job:"actor", language:"Turkish"},
  {userName:"Takis", job:"star", language:"Greek"},
  {userName:"Joe", job:"star", language:"Turkish"},
  {userName:"Bill", job:"star", language:"Turkish"}
];

let unwantedFieldsFilter= { 
  userName: ['Mary', 'Joe'],    
  job: ['actor'],   
  language: ['English', 'Italian', 'Spanish', 'Greek']  
};

const state.contactList = [{
    name: 'jane',
    email: 'jane@gmail.com'
  },{},{},...]

const fileredArray = state.contactsList.filter((contactItem) => {
  const regex = new RegExp(`${action.payload}`, 'gi');
  return contactItem.nameProperty.match(regex) || 
    contactItem.emailProperty.match(regex);
});


// contactList: all the contacts stored in state
// action.payload: whatever typed in search field

b=[]; 
yourArray.forEach(x => {
      Object.keys(x).forEach(i => {if (x[i].match('5') && !b.filter(y => y === x).length) { b.push(x) }})
    });
console.log(b)