javascript将多维数组值添加到新数组

我有一个多维数组，比如

var arr = [[1,2,3],[1,3,2],[1,1,1]];

我想把每列的矩阵列加在一个新数组中。我期望的结果是[3,6,6]。这就是我想出的解决办法

function compute(arr) {
    var X = _.reduce(arr, function(acc, j) {
        acc += j[0];
        return acc;
    },0);
    var Y = _.reduce(arr, function(acc, k) {
        acc += k[1];
        return acc;
    },0);
    var Z = _.reduce(arr, function(acc, l) {
        acc += l[2];
        return acc;
    },0);
    return [X,Y,Z];
}

它正在工作，但似乎有3个reduce函数。我正在寻找一个更清洁，更功能，更快的解决方案使用洛达斯

---

我在想也许我可以使用u.flatte函数，因为你可以为每次迭代传递一个函数，但我似乎无法避免所有的循环。有什么建议吗？

您可以在函数中声明一个函数来处理索引和数组：

function compute(arr) {

    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }

    var X = reduce(0);
    var Y = reduce(1);
    var Z = reduce(2);

    return [X,Y,Z];
};

如果你想把它缩短一点，你也可以这样做：

function compute(arr) {
    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }

    return [reduce(0), reduce(1), reduce(2)];
};

如果你想把它做得更短，你也可以这样做。这个函数的功能性更强一些，因为您将函数作为参数传递给

\uuu.map

function compute(arr) {
    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }
    return _.map([0, 1, 2], reduce);
};

---

您可以在此处查看结果：

您可以在函数中声明一个函数，用于处理索引和数组：

function compute(arr) {

    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }

    var X = reduce(0);
    var Y = reduce(1);
    var Z = reduce(2);

    return [X,Y,Z];
};

如果你想把它缩短一点，你也可以这样做：

function compute(arr) {
    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }

    return [reduce(0), reduce(1), reduce(2)];
};

如果你想把它做得更短，你也可以这样做。这个函数的功能性更强一些，因为您将函数作为参数传递给

\uuu.map

function compute(arr) {
    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }
    return _.map([0, 1, 2], reduce);
};

---

您可以在此处查看结果：

您可以在函数中声明一个函数，用于处理索引和数组：

function compute(arr) {

    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }

    var X = reduce(0);
    var Y = reduce(1);
    var Z = reduce(2);

    return [X,Y,Z];
};

如果你想把它缩短一点，你也可以这样做：

function compute(arr) {
    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }

    return [reduce(0), reduce(1), reduce(2)];
};

如果你想把它做得更短，你也可以这样做。这个函数的功能性更强一些，因为您将函数作为参数传递给

\uuu.map

function compute(arr) {
    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }
    return _.map([0, 1, 2], reduce);
};

---

您可以在此处查看结果：

您可以在函数中声明一个函数，用于处理索引和数组：

function compute(arr) {

    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }

    var X = reduce(0);
    var Y = reduce(1);
    var Z = reduce(2);

    return [X,Y,Z];
};

如果你想把它缩短一点，你也可以这样做：

function compute(arr) {
    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }

    return [reduce(0), reduce(1), reduce(2)];
};

如果你想把它做得更短，你也可以这样做。这个函数的功能性更强一些，因为您将函数作为参数传递给

\uuu.map

function compute(arr) {
    var reduce = function (index) {
        return _.reduce(arr, function(acc, array) {
            acc += array[index];
            return acc;
        },0);
    }
    return _.map([0, 1, 2], reduce);
};

---

您可以在这里查看结果：

一种使用香草的简单方法，以避免出现内部异常：

var arr = [[1,2,3],[1,3,2],[1,1,1]];

function sum(a,b){return a+b;}
function pluck(a){return a[this];}


arr.map(function(a,b,c){
   return c.map(pluck,b).reduce(sum);
}); // == [3, 6, 6]

下划线/lodash中的内容相同：

var arr = [[1,2,3],[1,3,2],[1,1,1]];   

function sum(a,b){return a+b;}

_.map(arr, function(a,b,c){
  return _.reduce(_.pluck(c, b), sum);
}); // == [3, 6, 6]

就我个人而言，我喜欢数组方法的本机链接，所以我不必平衡paren，但两种方法都可以

---

使用不同的低级可互换部件比使用一个大程序更好，这样您可以减少、重复使用和循环使用您的击键，因为您发现自己以后需要做几乎相同的事情。

使用香草避免内部异常的简单方法：

var arr = [[1,2,3],[1,3,2],[1,1,1]];

function sum(a,b){return a+b;}
function pluck(a){return a[this];}


arr.map(function(a,b,c){
   return c.map(pluck,b).reduce(sum);
}); // == [3, 6, 6]

下划线/lodash中的内容相同：

var arr = [[1,2,3],[1,3,2],[1,1,1]];   

function sum(a,b){return a+b;}

_.map(arr, function(a,b,c){
  return _.reduce(_.pluck(c, b), sum);
}); // == [3, 6, 6]

就我个人而言，我喜欢数组方法的本机链接，所以我不必平衡paren，但两种方法都可以

---

使用不同的低级可互换部件比使用一个大程序更好，这样您可以减少、重复使用和循环使用您的击键，因为您发现自己以后需要做几乎相同的事情。

使用香草避免内部异常的简单方法：

var arr = [[1,2,3],[1,3,2],[1,1,1]];

function sum(a,b){return a+b;}
function pluck(a){return a[this];}


arr.map(function(a,b,c){
   return c.map(pluck,b).reduce(sum);
}); // == [3, 6, 6]

下划线/lodash中的内容相同：

var arr = [[1,2,3],[1,3,2],[1,1,1]];   

function sum(a,b){return a+b;}

_.map(arr, function(a,b,c){
  return _.reduce(_.pluck(c, b), sum);
}); // == [3, 6, 6]

就我个人而言，我喜欢数组方法的本机链接，所以我不必平衡paren，但两种方法都可以

---

使用不同的低级可互换部件比使用一个大程序更好，这样您可以减少、重复使用和循环使用您的击键，因为您发现自己以后需要做几乎相同的事情。

使用香草避免内部异常的简单方法：

var arr = [[1,2,3],[1,3,2],[1,1,1]];

function sum(a,b){return a+b;}
function pluck(a){return a[this];}


arr.map(function(a,b,c){
   return c.map(pluck,b).reduce(sum);
}); // == [3, 6, 6]

下划线/lodash中的内容相同：

var arr = [[1,2,3],[1,3,2],[1,1,1]];   

function sum(a,b){return a+b;}

_.map(arr, function(a,b,c){
  return _.reduce(_.pluck(c, b), sum);
}); // == [3, 6, 6]

就我个人而言，我喜欢数组方法的本机链接，所以我不必平衡paren，但两种方法都可以

---

---

使用不同的低级可互换部件比使用一个大程序更好，这样，当您发现自己以后需要再次执行几乎相同的操作时，您可以减少、重复使用和回收您的击键。

基于回调而不是anon，这样您就可以执行返回映射（[0,1,2]，sumCounter）；LoDash似乎没有zipWith，太糟糕了……zipWith正是我要找的。哈哈，太糟糕了。应该在haskell中重写它：）基于回调而不是anon，这样您就可以执行return.map（[0,1,2]，sumCounter）；LoDash似乎没有zipWith，太糟糕了……zipWith正是我要找的。哈哈，太糟糕了。应该在haskell中重写它：）基于回调而不是anon，这样您就可以执行return.map（[0,1,2]，sumCounter）；LoDash似乎没有zipWith，太糟糕了……zipWith正是我要找的。哈哈，太糟糕了。应该在haskell中重写它：）基于回调而不是anon，这样您就可以执行return.map（[0,1,2]，sumCounter）；LoDash似乎没有zipWith，太糟糕了……zipWith正是我要找的。哈哈，太糟糕了。应该在haskell中重写：）这个答案需要一个正方形矩阵才能正常工作。若要查看故障，请向阵列中添加另一个三元组，或删除阵列的最后一个三元组。或者看看这把小提琴：。我知道这个答案很古老，但我想这条评论对任何在这个话题上绊倒的人都会有帮助。。。这是处理lodash中基质添加的唯一方法之一。最后一个提示。。。从v3.8开始，lodash包含了u.zipWith。@SteveHenty：在这种情况下，您可以简单地交换内部和外部：有趣的是，您应该提到这个解决方案。。。这与我在这里提出的相同，尽管是在lodash 4.x语义中：。依靠任意数组元素来计算列数，依靠闭包来访问完整的数组，这仍然让人感觉有点“骇客”。。。但它是有效的。最后一个音符。。。lodash提供了一种更接近本机“可读性”的链接语法：这个答案需要一个正方形矩阵才能正常工作。若要查看故障，请向阵列中添加另一个三元组，或删除阵列的最后一个三元组。或者看看这把小提琴：。我意识到这是一个错误