你应该能用 reduce .

var sum = array.reduce(function(pv, cv) { return pv + cv; }, 0);

Source

与 arrow functions 在ES6中引入,它更简单:

sum = array.reduce((pv, cv) => pv + cv, 0);

改进

您的循环结构可以更快:

   var count = 0;
   for(var i=0, n=array.length; i < n; i++) 
   { 
      count += array[i]; 
   }

这个检索 array.length 一次,而不是每次迭代。通过缓存值进行优化。

如果你真的想加快速度:

   var count=0;
   for (var i=array.length; i--;) {
     count+=array[i];
   }

这相当于while-reverse循环。它缓存值并与0进行比较,从而加快迭代速度。

有关更完整的比较列表,请参见 JSFiddle .
注: array.reduce在那里很糟糕,但在Firebug控制台中它是最快的。

比较结构

我开始了 JSPerf 用于数组求和。它建造得很快,不保证完整或准确,但这就是 编辑 是:

在寻找求和数组的最佳方法时,我编写了一个性能测试。

在铬合金中,“还原”似乎是非常优越的。

我希望这有帮助

// Performance test, sum of an array
  var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  var result = 0;
// Eval
  console.time("eval");
  for(var i = 0; i < 10000; i++) eval("result = (" + array.join("+") + ")");
  console.timeEnd("eval");
// Loop
  console.time("loop");
  for(var i = 0; i < 10000; i++){
    result = 0;
    for(var j = 0; j < array.length; j++){
      result += parseInt(array[j]);
    }
  }
  console.timeEnd("loop");
// Reduce
  console.time("reduce");
  for(var i = 0; i < 10000; i++) result = array.reduce(function(pv, cv) { return pv + parseInt(cv); }, 0);
  console.timeEnd("reduce");
// While
  console.time("while");
  for(var i = 0; i < 10000; i++){
    j = array.length;
    result = 0;
    while(j--) result += array[i];
  }
  console.timeEnd("while");

评估:5233.000毫秒

循环:255.000毫秒

减少:70.000 ms

而:214.000毫秒

最快的循环,根据 this test 是反向的while循环

var i = arr.length; while (i--) { }

所以,这个代码可能是最快的

Array.prototype.sum = function () {
    var total = 0;
    var i = this.length; 

    while (i--) {
        total += this[i];
    }

    return total;
}

Array.prototype.sum 向数组类添加sum方法…您可以很容易地使它成为一个助手函数。

或者你可以用邪恶的方式。

var a = [1,2,3,4,5,6,7,8,9];

sum = eval(a.join("+"));

;)

对于您的特定情况,只需使用 reduce 数组方法:

var sumArray = function() {
    // Use one adding function rather than create a new one each
    // time sumArray is called
    function add(a, b) {
        return a + b;
    }

    return function(arr) {
        return arr.reduce(add);
    };
}();

alert( sumArray([2, 3, 4]) );

基于 this test (for-vs-forEach-vs-reduce) 和 this (loops)

我可以这样说:

1最快:用于循环

var total = 0;

for (var i = 0, n = array.length; i < n; ++i)
{
    total += array[i];
}

2α骨料

对于你来说,你不需要这个,但它增加了很多灵活性。

Array.prototype.Aggregate = function(fn) {
    var current
        , length = this.length;

    if (length == 0) throw "Reduce of empty array with no initial value";

    current = this[0];

    for (var i = 1; i < length; ++i)
    {
        current = fn(current, this[i]);
    }

    return current;
};

用途:

var total = array.Aggregate(function(a,b){ return a + b });

不确定的方法

然后来 forEach 和 reduce 它们的性能几乎相同,并且因浏览器而异,但它们的性能却最差。

最简单、最快速、更可重用和更灵活的方法之一是:

Array.prototype.sum = function () {
    for(var total = 0,l=this.length;l--;total+=this[l]); return total;
}

// usage
var array = [1,2,3,4,5,6,7,8,9,10];
array.sum()

两头加起来怎么样?这会把时间缩短一半。像这样:

1,2,3,4,5,6,7,8;和=0

2,3,4,5,6,7;总和=10

3、4、5、6;总和=19

4, 5;和=28

求和=37

一种算法可以是:

function sum_array(arr){
    let sum = 0,
        length = arr.length,
        half = Math.floor(length/2)

    for (i = 0; i < half; i++) {
        sum += arr[i] + arr[length - 1 - i]
    }
    if (length%2){
        sum += arr[half]
    }
    return sum
}

当我在浏览器上用 performance.now() . 我认为这是更好的方法。你们觉得怎么样?