Javascript 高效/优雅地垂直求和数组（矩阵）的总和

在Javascript中，如果我有一个表示矩阵的数组，比如

x = [
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12]
];

“水平”求和很容易，可以像

x.map(function(y){
    return y.reduce(function(a,b){
        return a+b;
    });
});

现在我想计算“垂直”和，这是可以做到的

x.reduce(function(a, b){
    return a.map(function(v,i){
        return v+b[i];
    });
});

但我对这个版本不满意，我希望有更好、更优雅、更直截了当的版本。也许是一个简单的方法来事先转置矩阵？有人吗

---

请注意，几天前我问了一个类似的问题（），但这没有更大的图景。

只有我提出的方阵才是真正优雅的

   x = [[1,2,3,4],
        [5,6,7,8],
        [9,10,11,12]
    ];
    var sum = function(arr) {
      return arr.reduce(function(a, b){ return a + b; }, 0);
    };

    x.map(function(row, i) {
      return sum(x.map(function(row) { return row[i]; }));
    });

带有控制台日志的示例

对于任何尺寸的矩阵，都不那么优雅，但可能会在路上帮助您：

---

您可以对同一索引中的值求和

使用：

array.reduce（sum）

var和=（r，a）=>r.map（（b，i）=>a[i]+b）；
log（[[1,2,3,4]，[5,6,7,8]，[9,10,11,12]].reduce（sum））
.as console wrapper{max height:100%！important；top:0；}
我认为您不满意没有原生的
zip
函数，因为这就是
映射中的
reduce
的基本功能。您要么自己实现它，要么从库中导入它，比如，为了编写这样优雅的代码：

var verticalSum = x.map(R.zipWith(function(a,b){ return a+b; }));

如果您正在寻找一个有效的解决方案，基本上没有比显式循环更好的方法了

arrayOfArrays = [
  [1,2,3,4],
  [5,6,7,8],
  [9,10,11,12]
];

arrayOfArrays.reduce(function(array1, array2) {
  return array1.map(function(value, index) {
    return value + array2[index];
  });
});

为了我自己的利益，也为了其他人的利益，我想解释嵌套的
reduce
/
map
方法如何执行等长数组的垂直求和。这是OP提供的完全可以接受的版本

reduce
方法对累加器和数组的每个值应用一个函数，从左到右将其减少为单个值（）

在本例中，在第一次迭代中，前两个数组作为
array1
和
array2
传递到
reduce
的回调函数中。回调函数的返回值是应用于array1的
map
方法的结果

map
返回一个新数组，其中包含对数组的每个元素调用所提供函数的结果。（）

因此
map
迭代
array1
中的每个值，并将其添加到
array2
中相同索引位置的值中。这些结果被推送到一个新数组中，然后返回到
reduce
方法

刚刚返回的和数组现在成为新的
array1
，并且
reduce
调用其函数，将新的
array1
和下一个数组作为新的
array2
传递

重复此操作，直到
arrayOfArrays

首先是：

arrayOfArrays = [
  [1,2,3,4],
  [5,6,7,8],
  [9,10,11,12]
];

reduce过程的第一次迭代：

array1 [1,2,3,4]
array2 [5,6,7,8]

调用
reduce
的回调函数。
reduce的返回值
是通过使用
map
将
array1的每个值添加到
array2
在相同位置的值：

array1 [1,2,3,4]
array2 [5,6,7,8]
return [6,8,10,12]

此值将返回到
reduce
方法并成为新值
阵列1
<然后，代码>数组1
和下一个数组（
数组2
）再次传递到
reduce
回调函数，并通过
map
方法求和：

array1 [6,8,10,12]
array2 [9,10,11,12]
return [15,18,21,24]   // returned by map()

使用此函数，可以使用递归性对任意维度的数组求和：

function sumRecursiveArray(arr) {
  return arr.reduce(function(acc, value) {
    return acc + (Array.isArray(value) ? sumRecursiveArray(value) : value);
  }, 0);
}

var sum = sumRecursiveArray([[1,1,1],[2,2,2]]);
console.log(sum); // 9

你认为这到底有什么错？第一个例子中的矩阵不是正方形；）我不想要数组的和，而是列的和。谢谢你的回答！