如何找到 JavaScript 对象之间的共同属性

Question

找到对象数组的共同/不同属性的最佳/最有效方法是什么。

我需要识别存在于所有对象中并且都具有相同值（共同点）的属性集。 最好我还想获得一个具有所有其他属性（差异）的数组。

我已经搜索了可以做到这一点的高效库/函数。但是什么也没找到。所以我自己尝试了。

考虑这个 JS 对象数组：

var objects = [{
    id: '2j2w4f',
    color: 'red',
    height: 20,
    width: 40,
    owner: 'bob'
}, {
    id: '2j2w3f',
    color: 'red',
    height: 20,
    width: 41,
    owner: 'bob'
}, {
    id: '2j2w2f',
    color: 'red',
    height: 21,
}, {
    id: '2j2w1f',
    color: 'red',
    height: 21,
    width: 44
}];

我想将color（值为red）标识为唯一的公共属性。 请注意，它们没有相同的一组属性。例如。 owner 不是公共属性。

这是我自己尝试解决的问题（使用 lodash）：

function commonDifferentProperties(objects) {
    // initialize common as first object, and then remove non-common properties.
    var common = objects[0];
    var different = [];
    var i, obj;

    // iterate through the rest (note: i === 0 is not supposed to be covered by this)
    for (i = objects.length - 1; i > 0; i--) {
        obj = objects[i];
        // compare each property of obj with current common
        _.forOwn(obj, function (value, key) {
            // if property not in current common it must be different
            if (_.isUndefined(common[key])) {
                if (!_.contains(different, key)) {
                    different.push(key);
                }
            } else if (common[key] !== value) { // remove property from common if value is not the same
                delete common[key];
                different.push(key);
            }
        });

        // check that all properties of common is present in obj, if not, remove from common.
        _.forOwn(common, function (value, key) {
            if (_.isUndefined(obj[key])) {
                delete common[key];
                different.push(key);
            }
        });

    }

    return {
        common: common,
        different: different
    };
}

jsFiddle with the example

我也尝试了 mapReduce 方法，但似乎更糟。

我仍然认为这似乎有点复杂/耗时，我将对 1000-10000 个或更多对象执行此操作，每个对象具有 20-50 个属性。

有什么建议吗？

Answer 1

您的解决方案中有两点看起来有问题：

• var common = objects[0]; 你不会复制对象，所以你会破坏objects
• 您既检查 obj 中是否存在 common 的所有属性，还要将 obj 的每个属性与当前 common 进行比较。这似乎太过分了。 一开始并没有意识到您也需要 different 属性。

我会在两遍中循环遍历数据。首先，您收集一个对象中的所有明显属性，然后测试它们是否常见：

function commonDifferentProperties(objects) {
    var common = _.reduce(objects, function(acc, obj) {
        for (var p in obj)
            acc[p] = obj[p];
        return acc;
    }, {});
    var different = _.reduce(objects, function(acc, obj) {
        for (var p in common)
            if (common[p] !== obj[p]) {
                delete common[p];
                acc.push(p);
            }
        return acc;
    }, []);
    return {
        common: common,
        different: different
    };
}

Answer 2

这是我只使用香草 JS 所做的：

function commonDifferentProperties(objects) {
    var common = JSON.parse(JSON.stringify(objects[0]));
    var unmatchedProps = {};
    for (var i = 1; i < objects.length; i++) {
        for (var prop in objects[i]) {
            checkProps(objects[i],common,prop);
        }
        for (var commProp in common) {
            checkProps(common,objects[i],commProp);
        }
    }
    console.log(common);            // this is all the matched key/value pairs
    console.log(unmatchedProps);    // this is all the unmatched keys

    return { common: common, different: unmatchedProps };

    function checkProps(source, target, prop) {
        if (source.hasOwnProperty(prop)) {
            var val = source[prop];
            if (!target.hasOwnProperty(prop) || target[prop] !== val) {
                unmatchedProps[prop] = true;     // note: you could extend this to store values, or number of times you found this key, or whatever
                delete common[prop];
            }
        }
    }
}

http://jsfiddle.net/TwbPA/

所以我复制了第一个对象并使用它来跟踪常见的键和值。然后我遍历数组中的所有其他对象，首先查看公共对象中的所有键/值并与当前对象进行比较，如果它们不在当前对象中，则从公共对象中删除任何缺失的属性，然后我做反向捕获当前对象中不属于公共对象的任何属性（或在当前对象中，但具有错误的值）。

Answer 3

编辑

对不起，我很着急，没有足够的时间考虑。 确实，不需要排序。我正在考虑使用二进制算法或其他东西..

这里，更新后的代码没有排序。 Console.time() 给了我'3ms'。 我正在做类似于 Bergi 的解决方案，但不是收集所有明显的属性，而是搜索具有最少属性的元素。这减少了第二个循环的迭代次数。

我的代码基于以下内容：

• 如果对象 X 具有所选对象没有的属性，则它不是公共属性！
• 因此，所选对象具有所有常见属性 + 额外属性。
• 所选对象的属性最少，因此验证的迭代次数较少。

http://jsfiddle.net/kychan/cF3ne/1/

//    returns the common properties of given array.
function getCommonProps(objects)
{
    //    storage var for object with lowest properties.
    var lowest = {obj:null, nProperties:1000};

    //    search for the object with lowest properties. O(n).
    for (var j in objects)
    {
        var _nProp = Object.keys(objects[j]).length;

        if (_nProp < lowest.nProperties)
            lowest = {obj:objects[j], nProperties:_nProp};
    }

    //    var that holds the common properties.
    var retArr = [];

    //    The object with the fewest properties should contain common properties.
    for (var i in lowest.obj)
        if (isCommonProp(objects, i))    retArr.push(i);

    return retArr;
}

//    Checks if the prop exists in all objects of given array.
function isCommonProp(arr, prop)
{
    for (var i in arr)
    {
        if (arr[i][prop]===undefined)
            return false;
    }

    return true;
}

console.time('getCommonProps()_perf');
console.log(getCommonProps(objects));
console.timeEnd('getCommonProps()_perf');

Answer 4

这是使用reduce() 和transform() 的另一种方法：

_.reduce(objects, function(result, item) { 
    if (_.isEmpty(result)) {
        return _.assign({}, item);
    }

    return _.transform(item, function(common, value, key) {
        if (result[key] === value) {
            common[key] = value;
        }
    }, {});
}, {});