Question

我正在构建Mixitup的过滤方法，我需要能够正确过滤x选定的参数。（这里的插件并不重要，它是我如何获得正确的结束对象）

我目前有一个对象，每个唯一的搜索都会发送一个唯一的密钥，并将其匹配的对象（通过filter方法获得）发送到我的过滤函数中。

这是我迷失的地方。

我需要能够遍历我的对象，并且它的关联键=＆gt;值（对象），并仅提取每个对象中存在的对象。

例如，（而不是数字我有jQuery对象）

var filter = {
    x : {1,3,5,6},
    y : {1,4,7,8},
    z : {1,9}
}

基于上面的例子，唯一返回的对象是-1（因为它是唯一存在于所有三个键中的对象。

非常感谢任何帮助！

Answer 1

使用Array.reduce和Array.filter的简短方法：

基本上它从第一个数组开始作为reduce的起始值。然后通过查找索引来过滤结果集，如果找到，则值保持不变，否则跳过该值。这一直持续到对象没有更多属性。

＆＃13;

var filter = {
    x: [1, 3, 5, 6],
    y: [1, 4, 7, 8],
    z: [1, 9]
};

var filtered = Object.keys(filter).reduce(function (r, a, i) {
    return i ? r.filter(function (b) {
        return ~filter[a].indexOf(b);
    }) : filter[a];
}, []);

document.write('<pre>' + JSON.stringify(filtered, 0, 4) + '</pre>');

＆＃13;

奖励对象，返回公共密钥：

＆＃13;

var filter = {
    x: { a: 'ah', c: 'ce', e: 'eh', f: 'ef' },
    y: { a: 'ah', d: 'de', g: 'ge', h: 'ha' },
    z: { a: 'ah', i: 'ie' }
};

var filtered = Object.keys(filter).reduce(function (r, a, i) {
    return i ? r.filter(function (b) {
        return b in filter[a];
    }) : Object.keys(filter[a]);
}, []);

document.write('<pre>' + JSON.stringify(filtered, 0, 4) + '</pre>');

＆＃13;

Answer 2

所以，我会分两部分来做：

1找到常用项目

2提取常用项目

var filter = {
    x : [1,3,5,6],
    y : [1,4,7,8],
    z : [1,9]
}

// Find the common
var common;
Object.keys(filter).forEach(function (k) {
    if (common) {
         for (var i=0; i<common.length; i++) {
             // Check if the common value exists on the key
             if (filter[k].indexOf(common[i]) === -1) {
                 // If it does not, it is not common
                 common.splice(i, 1);
                 i--;
             }
         }
    } else {
        // On the first item, we assume all are common
        common = filter[k]
    }
})

// Additional processing can take place to extract the data you need here
//Should print "[1]"
console.log(common)

Answer 3

这是一个解决方案：这里我使用了相同的数据结构，而没有将其转换为数组

HTML

<p id="result"></p>

的JavaScript

var value = 'value',
    filter = {
        x : {1:value,3:value,5:value,6:value,9:value},
        y : {1:value,4:value,7:value,8:value,9:value},
        z : {1:value,9:value}
    };

function getCommon(data) {
    var subObjects = [],
        common = [];

    if(typeof data === 'object'){

        // collect all sub-keys into an array
        Object.keys(data).forEach(function(key){
            if(typeof data[key] === 'object') {
                subObjects = subObjects.concat(Object.keys(data[key]));
            }
        });

        // get the common keys
        Object.keys(data[Object.keys(data)[0]]).forEach(function(subKey){
            if(getCount(subObjects, subKey) === Object.keys(data).length) {
                common.push(subKey);
            }
        });

        function getCount(data, target){
            return data.filter(function(item){
                return item === target;
            }).length;
        }

        return common;
    }
}

document.getElementById('result').innerHTML = getCommon(filter);

JSFiddle：http://jsfiddle.net/LeoAref/bbnbfck7/

比较对象并仅获取所有对象

3 个答案: