Question

我想比较数组中无限量的对象，比如

{ a: true, b: false, c: "foo"}

和

{ a: false, b: false, c: "foo"}

得到像

这样的结果

[b,c]

这可以通过两个这样的对象完成：

function compare(first, second) {
    var shared = []
    $.each(first, function(index, value){
        if(second[index] == value){
            shared.push(index)
        }
    })
    return shared
}

所以我的问题是：如何编写一个（递归）函数来比较 n 对象并返回它们共有的属性。

感谢您阅读本文

Answer 1

如果按字面意思写的话，这很简单：

function allCommonProperties(objects) {
    if (!objects.length) return [];
    var first = objects[0];
    return Object.keys(first).filter(function(p) {
        return objects.every(function(o) {
             return first[p] === o[p];
        });
    });
});

不需要递归，不需要jQuery。

Answer 2

我会使用.reduce()进行操作，遍历数组并累积一个对象，该对象仅包含到目前为止在所有对象中找到的属性（具有匹配值）。

我将给我的例子一个“扩展”功能;如果你正在使用jQuery，你可以使用$.extend()，或者你可以写一个简单的。我们的想法是将属性的浅表副本从一个对象复制到另一个对象，这对于列表中的第一个对象是必需的。

var objects = [ ... ]; // the array of objects
var resultObject = objects.reduce(function(result, obj) {
  if (result === null)
    result = extend({}, obj);
  else {
    Object.keys(result).forEach(function(key) {
      if (!(key in obj) || obj[key] !== result[key])
        delete result[key];
    });
  }
  return result;
}, null);
var resultProperties = Object.keys(resultObject);

以下是extend()的样子：

function extend(obj) {
  var args = arguments;
  for (var i = 1; i < args.length; ++i)
    Object.keys(args[i]).forEach(function(key) {
      obj[key] = args[i][key];
    });
  return obj;
}

Answer 3

使用.filter和.every的替代方法。没有图书馆。

Object.keys(first)
      .filter(function(key){
          return objects.every(function(obj){
             return obj[key] === first[key];
          });
      });

对于ES6 envs

Object.keys(first).filter(key => objects.every(obj => obj[key] === first[key]));

其中

objects - 要比较的所有对象的数组
first = objects.shift() - 第一个元素

Answer 4

此解决方案将Array.prototype.filter与Object.keys结合使用。

var setA = { a: true, b: false, c: "foo" },
    setB = { a: false, b: false, c: "foo" },
    commonProperties = Object.keys(setA).filter(function (k) {
        return setA[k] === setB[k];
    });

document.write('<pre>' + JSON.stringify(commonProperties, 0, 4) + '</pre>');

Answer 5

我认为这项工作：

function compareObj(obj1,obj2){
    var ar =[];//you need an  array to put the diffirent property
    for(key in obj1){//getting all proo
        try{
            if (obj1[key]!=obj2[key]) //if there is diffirence 
                {
                    ar[ar.length-1]=key;
                    //key is the name of property 
                }
        }
        catch(err){
            console.log("Not the same type of objects");
            return false;
        }


    }
    return ar ;
}

Answer 6

尝试尽可能少地迭代。每次在下一个对象上找不到属性时，它会变换一个包含初始对象键的数组，并且如果没有公共属性，它也会停止迭代其余的数组元素。

＆＃13;

m32()

＆＃13;

function filterByPropertyValue(arr) {
  var acc = {},
    initial, objectProperties;
  if (arr.length > 0) {
    initial = arr[1];
    objectProperties = Object.keys(initial);
    for (var i = 1; i < arr.length; i++) {
      if (objectProperties.length > 0) {
        objectProperties.forEach(function(prop, index) {
          if (initial[prop] === arr[i][prop]) {
            acc[prop] = initial[prop];
          } else {
            delete acc[prop];
            delete objectProperties[index];
          }
        });
      } else {
        break;
      }
    }
  }
  return acc;
}

var arr = [{ a: true, b: false, c: "foo"}, { a: false, b: false, c: "foo"}, { a: true, b: false, c: "bar"}];
document.getElementById('results').innerHTML = JSON.stringify(filterByPropertyValue(arr), null, '\t');

＆＃13;

比较数组

6 个答案: