我有一个对象数组，像这样:

const data = [                 // array1
  [{x: 1}, {y:2}, {z:3}], 
  [{x: 1}, {y:2}, {z:3}],
  [{x: 1}, {y:2}, {z:3}]
],[                            // array2
  [{x: 1}, {y:2}, {z:3}], 
  [{x: 1}, {y:2}, {z:3}],
  [{x: 1}, {y:2}, {z:3}]
]

需要完成的是将 array1 中的 x 与 array2 中的 x 相加相同的指数。 y 和 z 也是如此。最终结果应该是包含求和值的新对象数组。

像这样:

[
  [{totalXOne: 2}, {totalYOne: 4}, {totalZOne: 6}],
  [{totalXTwo: 2}, {totalYTwo: 4}, {totalZTwo: 6}],
  [{totalXThree: 2}, {totalYthree: 4}, {totalZThree: 6}],
]

注意:所有数组的长度都相同，如果缺少一个值，它将被替换为0)

我在 MDN 上发现了一些不错的东西，但它对所有 x、y、z 值求和，并且返回单个求和值，例如这个:

let initialValue = 0;
let sum = [{x: 1}, {x:2}, {x:3}].reduce(function(accumulator,currentValue) {
    return accumulator + currentValue.x;
}, initialValue)

输出:

[
  [{totalX: 3}, {totalY: 6}, {totalZ: 9}],  // this is not what I need
]

有什么办法可以实现吗？

更新

我正在从其他来源接收 JSON。它包含一个名为 allEmpsData 的属性，映射到它上面我得到了必要的 salaryData 并映射到它上面我得到了 NET|GROSS|TAX 数据。

let allReports = [];

    setTimeout(() => {

        allEmpsData.map(x => {
            let reports = {};

            let years = [];
            let months = [];

            let netArr = [];
            let grossArr = [];
            let mealArr = [];
            let taxArr = [];
            let handSalaryArr = [];

            x.salaryData.map(y => {
                years.push(y.year);
                months.push(y.month);
                    netArr.push(y.totalNetSalary);
                    grossArr.push(y.bankGrossSalary);
                    mealArr.push(y.bankHotMeal);
                    taxArr.push(y.bankContributes);
                    handSalaryArr.push(y.handSalary);
                })
                reports.year = years;
                reports.month = months;
                reports.net = netArr;
                reports.gross = grossArr;        
                reports.meal = mealArr;        
                reports.taxesData = taxArr;        
                reports.handSalaryData = handSalaryArr;
                allReports.push(Object.assign([], reports));
        });
    }, 1000);

据我所知，一切正常，但事实是，。我不知道更好。然后魔法就来了:

setTimeout(() => {
    result = allReports.reduce((r, a) =>
         a.map((b, i) =>
           b.map((o, j) =>
             Object.assign(...Object
              .entries(o)
               .map(([k, v]) => ({ [k]: v + (getV(r, [i, j, k]) || 0) }))
                    )
                )
            ),
            undefined
        );
            console.log(result);
        }, 1500);

... 它在 Node 控制台中返回一个空数组，但如果我 console.log 上面更新代码中的任何其他属性，它就在那里。有什么建议吗？

最佳答案

这是一种函数式编程方法，使用中间 ES6 Map:

const data = [[[{x: 1}, {y:2}, {z:3}], [{x: 1}, {y:2}, {z:3}], [{x: 1}, {y:2}, {z:3}]], [[{x: 1}, {y:2}, {z:3}], [{x: 1}, {y:2}, {z:3}],[{x: 1}, {y:2}, {z:3}]]];

const result = data[0].map( (arr, i) => Array.from(data.reduce( (acc, grp) => (
    grp[i].forEach( o =>
        Object.entries(o).forEach( ([k, v]) => acc.set(k, (acc.get(k) || 0) + v)) 
    ), acc
), new Map), ([k, v]) => ({ [k]: v })) ); 

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

说明

为了便于解释，让我们就一些条款达成一致:

我们有输入(一个数组)，由组组成。每个组 都是一个由行 组成的数组。每行由对象组成，每个对象都有一个属性/值对。

输出 没有组 级别，但它有行，同样由对象 组成，每个都有一个属性/值对。

因此，让我们使用这些术语来查看代码:

由于输出数组中的行数等于任何组中的行数，因此映射第一组的行似乎是一个好的开始，即像 data[0].map 。

对于输出中的每一行，我们都需要求和，reduce 是该工作的一个很好的候选函数，因此我们调用 data.reduce。对于 reduce 调用的初始值，我传递了一个空的 Map。目的是用键和对填充该 Map。稍后我们可以将该 Map 分解为单独的对象，每个对象仅具有这些键/和对之一(但那是为了以后)。

因此 reduce 以 Map 开始并遍历组。我们需要从每个组中取出第 i^th 行来找到必须“添加”的对象。所以我们取 grp[i] 行。

对于该行中的每个对象，我们使用 Object.entries(o) 获取属性名称和值。事实上，该函数返回一个数组，因此我们使用 forEach 对其进行迭代，因为我们知道实际上我们只会迭代一次，因为实际上那里只有一个属性。现在我们有了键 (k) 和值 v。我们处于输入结构的最深层次。这里我们调整累加器。

使用 acc.get(k) 我们可以知道我们已经为特定键(例如“x”)积累了什么。如果我们那里什么都没有，它会通过 || 初始化为 0 0。然后我们将当前值 v 添加到它，并使用 acc.set(k, ....) 将该总和存储回 Map。使用逗号运算符，我们将 acc 返回给 reduce 实现(我们可以在这里使用 return，但逗号运算符更简洁)。

因此 Map 获取每个键的所有总和。使用 Array.from，我们可以迭代每个键/和对，并使用回调参数，将该对转换为适当的小对象(使用 { [k]: v })。 [k] 表示法也是 ES6 中的一个新奇事物——它允许在对象字面量中使用动态键名。

所以... Array.from 返回一个小对象数组，每个对象都有一个总和。该数组代表要输出的一行。 map 方法创建输出中所需的所有行。

关于javascript - 迭代一个对象数组，对具有相同索引的值求和，并返回一个新的对象数组，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50784499/