Ответ 1

Вы можете использовать reduce.

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

Источник

И с функциями стрелок, представленными в ES6, это еще проще:

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

Ответ 2

Улучшения

Ваша структура циклов может быть выполнена быстрее:

   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. Он кэширует значение и сравнивается с 0, тем самым ускоряя итерацию.

Более полный список сравнения см. в разделе JSFiddle.
Примечание: array.reduce там ужасен, но в Firebug Console он быстрее всего.

Сравнить структуры

Я начал использовать JSPerf для суммирования массива. Он был быстро построен и не гарантированно был полным или точным, но что редактирование для:)

Ответ 3

При поиске наилучшего метода суммирования массива я написал тест производительности.

В Chrome "сокращение" кажется значительно превосходенным

Я надеюсь, что это поможет

// 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");

eval: 5233.000мс

loop: 255.000ms

уменьшить: 70.000 мс

в то время как: 214.000мс

Ответ 4

Самый быстрый цикл, согласно этот тест - это цикл 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 добавляет метод суммы в класс массива... вы можете легко сделать его вспомогательной функцией.

Ответ 5

В вашем конкретном случае просто используйте метод 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]) );

Ответ 6

Или вы могли бы сделать это злобным путем.

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

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

;)

Ответ 7

На основе этот тест (for-vs-forEach-vs-reduce) и этот (цикл)

Я могу сказать, что:

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, которые имеют почти такую ​​же производительность и варьируются от браузера к браузеру, но в любом случае они имеют наихудшую производительность.

Ответ 8

один из самых простых, быстрых, многоразовых и гибких:

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()