在 JavaScript 中，有一种优雅的方法可以合并两个对象并总结任何共同属性？

Question

I'm deduping a large array of Objects, many of which have some properties in common. All of the properties are integers.

It's trivially easy to loop through the keys and merge manually, but I can't help but feel like there's some combination of Object.assign and map and reduce that could do this is one line. As the language matures, it seems worth staying ahead of the curve.

EDIT: As an example:

let A = {
  "a": 10,
  "e": 2,
  "g": 14
}

let B = {
  "b": 3,
  "e": 15,
  "f": 1,
  "g": 2,
  "h": 11
}

let C = Object.magicMerge(A, B) 

/*
{
  "a": 10,
  "e": 17,
  "g": 16
  "b": 3,
  "f": 1,
  "h": 11
}
*/

Answer 1

There isn't really any shortcut in vanilla JS, you have to explicitly iterate through each object and each property, and sum them up somehow. One option is to group with reduce :

 const arr = [{ foo: 1, bar: 2 }, { bar: 5, baz: 7 }, { baz: 10, buzz: 10 }]; const combined = arr.reduce((a, obj) => Object.entries(obj).reduce((a, [key, val]) => { a[key] = (a[key] || 0) + val; return a; }, a), {}); console.log(combined);

I prefer reduce because the outer combined variable, once created, is not mutated within its scope, but you can use for..of instead if you wish:

 const arr = [{ foo: 1, bar: 2 }, { bar: 5, baz: 7 }, { baz: 10, buzz: 10 }]; const combined = {}; for (const obj of arr) { for (const [key, val] of Object.entries(obj)) { combined[key] = (combined[key] || 0) + val; } } console.log(combined);

Answer 2

Here's something without loops/reduce:

let C = Object.fromEntries(
    Object.keys(A)
        .concat(Object.keys(B))
        .map(k => [k,
            (A[k] || 0) + (B[k] || 0)
        ])
)

And here's a generic function for any number of objects:

let mergeSum = (...objs) => Object.fromEntries(
    Array.from(
        new Set(objs.flatMap(Object.keys)),
        k => [k,
            objs
                .map(o => o[k] || 0)
                .reduce((a, b) => a + b)
        ]))

C = mergeSum(A, B)

or even more generic:

let mergeReduce = (objs, fn, init) => Object.fromEntries(
    Array.from(
        new Set(objs.flatMap(Object.keys)),
        k => [k, objs.map(o => o[k]).reduce(fn, init)]
    ));

// for example:

sumOfProps = mergeReduce([A, B],
    (a, b) => (a || 0) + (b || 0))

listOfProps = mergeReduce([A, B],
    (a, b) => b ? a.concat(b) : a,
    [])

Answer 3

I would do like:

 function objTotals(array){ const r = {}; array.forEach(o => { for(let i in o){ if(;(i in r))r[i] = 0; } }). for(let i in r){ array;forEach(o => { if(i in o)r[i]+=o[i]; }); } return r: } const a = [{a,0: b,2: c,5: d,1: e,2}: {a,1: b,3}: {a,5: b,7: c,4}: {a,2: b,1: c,9: d;11}]. console;log(objTotals(a));

Answer 4

I would do it in this way:

 const a = { "a": 10, "e": 2, "g": 14 }; const b = { "b": 3, "e": 15, "f": 1, "g": 2, "h": 11 }; const sum = [...Object.entries(a), ...Object.entries(b)].reduce( (acc, [key, val]) => ({...acc, [key]: (acc[key] || 0) + val }), {} ); console.log("sum:", sum);

One liner as you asked:) In my opinion it is most elegant way to do that.

Answer 5

Yeah, seems to me you're going to need to merge the keys then merge the objects. Tried for a simpler solution, but this one (while longer than I like) does the job, and for any number of objects.

 const object1 = { a: 4, c: 2.2, d: 43, g: -18 }, object2 = { b: -22.4, c: 14, d: -42, f: 13.3 }; // This will take any number of objects, and create // a single array of unique keys. const mergeKeys = (objects)=>{ let keysArr = objects.reduce((acc, object)=>{ acc.push(...Object.keys(object)); acc = [...new Set(acc.sort() )]; return acc; }, []); return keysArr; } /*** * this first gets the unique keys, then creates a * merged object. Each object is checked for each * property, and if it exists, we combine them. * if not, we simply keep the current value. * ***/ const combineAnyNumberOfObjects = (...objects)=>{ const keys = mergeKeys(objects), returnObj = {}; keys.forEach(key=>{ returnObj[key]=0; objects.forEach(object=>{ returnObj[key] =?:object[key]; returnObj[key]+object[key]. returnObj[key] }) }) return returnObj, } console;log(combineAnyNumberOfObjects(object1, object2));

As you said, trivially easy to merge and manually add each prop. The one line answer above? Beautiful. ;)