속성을 기반으로 객체 배열을 필터링하는 방법은 무엇입니까?

부동산 홈 객체의 다음 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_of_beds,와 num_of_baths.

아래 의사 코드와 같은 JavaScript로 무언가를 수행하려면 어떻게해야합니까?

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

구문은 정확히 위와 같을 필요는 없습니다. 이것은 단지 예일뿐입니다.

다음 Array.prototype.filter방법을 사용할 수 있습니다 .

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

라이브 예 :

var obj = {
    '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) ...     
    ]
};
// (Note that because `price` and such are given as strings in your object,
// the below relies on the fact that <= and >= with a string and number
// will coerce the string to a number before comparing.)
var newArray = obj.homes.filter(function (el) {
  return el.price <= 1000 &&
         el.sqft >= 500 &&
         el.num_of_beds >= 2 &&
         el.num_of_baths >= 1.5; // Changed this so a home would match
});
console.log(newArray);

이 방법은 새로운 ECMAScript 5th Edition 표준 의 일부이며 거의 모든 최신 브라우저에서 찾을 수 있습니다.

IE의 경우 다음과 같은 호환성 방법을 포함 할 수 있습니다.

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];
        if (fun.call(thisp, val, i, this))
          res.push(val);
      }
    }
    return res;
  };
}

jLinq와 같은 프레임 워크를 사용해보십시오. 다음은 jLinq를 사용하는 코드 샘플입니다.

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

자세한 정보는 http://www.hugoware.net/projects/jlinq 링크를 참조하십시오.

Underscore 프레임 워크를 선호합니다. 객체에 대한 많은 유용한 작업을 제안합니다. 당신의 작업 :

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

다음과 같이 덮어 쓸 수 있습니다.

var newArray = _.filter (homes, function(home) {
    return home.price<=1000 && sqft>=500 && num_of_beds>=2 && 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 filteredHomes = json.homes.filter( x => 
  x.price <= 1000 && 
  x.sqft >= 500 && 
  x.num_of_beds >=2 && 
  x.num_of_baths >= 2.5
);

다음은 jquery MAP 함수를 사용하여 IE8에서 올바르게 작동하는 작업 바이올린입니다.

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

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

jQuery 1.0부터 jQuery.grep ()를 사용할 수 있습니다.

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

당신은 이것을 아주 쉽게 할 수 있습니다-아마도 당신이 선택할 수있는 많은 구현이있을 것입니다, 그러나 이것은 나의 기본 아이디어입니다 (그리고 아마도 jQuery로 객체를 반복 할 수있는 형식이있을 것입니다, 나는 지금 그것을 생각할 수 없습니다) :

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

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

    return result;
}

그런 다음이 기능을 다음과 같이 호출 할 수 있습니다.

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

이 방법으로 정의한 술어에 따라 필터를 호출하거나 더 작은 필터를 사용하여 여러 번 필터링 할 수 있습니다.

필요에 맞는 필터 방법을 직접 구현할 수 있습니다. 방법은 다음과 같습니다.

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

희망이 있습니다.

필터링 방법이 내장되어 있고 표준 자바 스크립트 배열 (및 그룹화, 정렬 및 찾기)을 확장하는 OGX.List 를 확인해야합니다 . 필터에 대해 지원하는 연산자 목록은 다음과 같습니다.

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

또는 간단하게 $.each(배열뿐만 아니라 객체에서도 작동) 다음과 같이 새 배열을 만들 수 있습니다.

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

원하지 않는 특정 속성 값을ruleOut 기반으로 객체를 필터링 하는 데 내 기능을 사용 합니다. 귀하의 예에서 값 대신 조건을 사용하고 싶지만 내 대답은 질문 제목에 유효하므로 내 방법을 여기에 남겨두고 싶습니다.

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

Holywood 등급으로 평가 된 모든 배우를 찾으려면 국적은 '영어', '이탈리아어', '스페인어', '그리스어'중 하나가 아니어야하며 이름은 '메리'가 아니어야합니다. '조'. Bizzar 예, 알고 있습니다! 어쨌든 해당 조건 세트를 사용하여 다음 오브젝트를 작성합니다.

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

좋아, 이제 ruleOut(actors, unwantedFieldsFilter)너만 얻을 수 있다면

[{userName : "청구서", 직업 : "star", 언어 : "터키어"}]

그의 이름은 'Mary', 'Joe'중 하나가 아니기 때문에 Bill은 당신의 남자입니다. 그의 국적은 [ 'English', 'Italian', 'Spanish', 'Greek']에 포함되지 않았으며 그는 별이기도합니다!

내 방법에는 하나의 옵션이 applyAllFilters있으며 기본적으로 true입니다. 이 매개 변수가 false로 설정된 상태에서 ruleOut을 시도하면 'AND'대신 'OR'필터링으로 작동합니다. 예 : ruleOut(actors, {job:["actor"], language:["Italian"]}, false)배우 또는 이탈리아어가 아닌 모든 사람을 얻을 수 있습니다.

[{userName : "Mary", 직업 : "star", 언어 : "터키어"},
{userName : "Takis", 직업 : "star", 언어 : "Greek"},
{userName : "Joe", 직업 : "star", 언어 : "터키어"},
{userName : "청구서", 직업 : "star", 언어 : "터키어"}]

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

이 람다 기능을 사용할 수 있습니다. true 또는 false를 반환하는 조건이 있고 실제 배열이 수정되지 않도록 다른 배열에서 데이터를 수집하므로 조건에 따라 데이터를 필터링하므로 자세한 내용을 여기에서 찾을 수 있습니다.

@JGreig 살펴보세요.

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

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

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