如何将对象列表简化为重复项

Question

[edited for clarity]

Using lodash, given an array of objects:

var v = [{'a':1, 'b':1}, {'a':1, 'b':2}, {'a':1, 'c':1}];

how do I return an object which is the intersection of those objects (both key and value)? In this case:

{'a':1}

I am looking for key value pairs which are in every object.

---

This seems like a task for _.reduce , but I am not sure how to find the object duplicates.

Answer 1

Indeed you can use Array#reduce with a hash object, and Object#keys to get all key:value pairs that appear in all objects.

 var v = [{'a':1, 'b':1}, {'a':1, 'b':2}, {'a': 1, 'c':1, 'b': 1}]; var hashCount = {}; var result = v.reduce(function(r, o) { Object.keys(o).forEach(function(key) { // iterate the object keys var hash = key + '_' + o[key]; // create the hash from the key:value pair hashCount[hash] = (hashCount[hash] || 0) + 1; // increment the hash in the hashCount // add the pair to the result when the hash count number is equal to the length of the array, if(hashCount[hash] === v.length) { r[key] = o[key]; } }); return r; }, {}); console.log(result); 

btw - my original answer was written to cope with the case of a property that appears in at at least two objects. So, if you just want to find a property that appears in 2 objects (or any arbitrary number), change this line if(hashCount[hash] === v.length) { to if(hashCount[hash] === 2) {

Answer 2

You could reduce the objects by iterating the keys and checking the values. Then build a new object and return.

 var array = [{ a: 1, b: 1 }, { a: 1, b: 2 }, { a: 1, c: 1 }], result = array.reduce(function (a, b) { return Object.keys(a).reduce(function (o, k) { if (a[k] === b[k]) { o[k] = a[k]; } return o; }, {}); }); console.log(result); 

ES6 with Object.assign

 var array = [{ a: 1, b: 1 }, { a: 1, b: 2 }, { a: 1, c: 1 }], result = array.reduce((a, b) => Object.keys(a).reduce((o, k) => Object.assign(o, a[k] === b[k] ? { [k]: a[k] } : {}), {})); console.log(result); 

Answer 3

Here's one way to do it with loDash

 var v = [{'a':1, 'b':1}, {'a':1, 'b':2}, {'c':1}]; let k = _.chain(v).map(Object.entries) .flatten(true) .filter((f,u,n) => { let i = _.findLastIndex(n, z => (_.isEqual(f,z))); return n.some((g,o) => (_.isEqual(f,g) && u!==o && u===i)); }) .map(x => ({[x[0]]:x[1]})) .value() console.log( k ) 

 <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script> 

It maps the objects back split up, then flattens it out, then filters based on object equality, using _.isEqual , not string comparison, then maps back the object and get the value from the chain

Answer 4

Solution using _.reduce :

var r = _.reduce(v.slice(1), function (result, item) {
    Object.keys(result).forEach(function (key) {
      if (!item.hasOwnProperty(key)) delete result[key];
    })
    return result;
  }, Object.assign({}, v[0]));

The idea is to use one item as the result, which is handed over to reduce() as third parameter (accumulator). That is done by copying the Object, since that is modified within the algorithm, like so: Object.assign({}, v[0]) .

Within the reduce function (second parameter) we check if the actual item for each Property of the result. If the item does not have it, we remove it from the result.

Since the first item of the list is already given to the function, it can be excluded from the array to reduce, what is done by v.slice(1) .

Why does that work:

1. Each item in the list can be used as the initial intersection, since we are looking for all properties that exist in all objects, we can safely say that we do not forget to include any other properties from any other object.

2. If an item does not have any property which is part of the intersection, that property is not part of the intersection and needs to be removed from there.

Note:

One downside of using reduce here is: It iterates over each item in the list, no matter if the intersection is already empty, where the algorithm could stop. So writing a regular function like the one below might be faster for large lists of objects, which are likely to have no intersection:

function intersect (list) {
  var 
    remain = [].concat(list),
    result = Object.assign({}, remain.pop()),
    keys = Object.keys(result),
    item;

  while ((item = remain.pop()) != undefined && keys.length > 0) {
    keys.forEach(function (key) {
      if (!item.hasOwnProperty(key)) delete result[key];
    });

    keys = Object.keys(result);
  }

  return result;
}