Самое быстрое суммирование JavaScript

Question

Какой самый быстрый способ суммировать массив в JavaScript?Быстрый поиск переворачивает несколько разных методов , но я бы хотел нативное решение, если это возможно.Это будет работать под SpiderMonkey.

Думая очень внутренне, я использовал:

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

Я уверен, что есть лучший способ, чем прямая итерация.

Answer 1

Вы должны быть в состоянии использовать reduce.

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

Источник

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

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

Answer 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 для суммирования массива.Он был быстро сконструирован и не гарантированно будет полным или точным, но для этого edit предназначен для:)

Answer 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мс

петля: 255.000мс

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

время: 214.000мс

Answer 4

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

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

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

;)

Answer 5

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

Answer 6

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

Answer 7

На основании этого теста (for-vs-forEach-vs-redu) и this (циклы)

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

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

Answer 8

Как насчет суммирования обеих конечностей?Это сократит время пополам.Вот так:

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().Я думаю, что это лучший способ.Что вы, ребята, думаете?

Answer 9

один из самых простых, быстрых, многократно используемых и гибких:

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