Más rápido de JavaScript suma

Usted debería ser capaz de utilizar reduce.

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

Fuente

Y con flecha funciones introducido en ES6, es aún más sencillo:

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

Mejoras

Su estructura de bucle podría hacerse más rápido:

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

Esta forma, se recupera array.length vez, en lugar de con cada iteración. La optimización se realiza mediante el almacenamiento en caché el valor.

Si usted realmente desea acelerar:

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

Esto es equivalente a una mientras que la inversa de bucle. Almacena el valor de y es comparado con el 0, por lo tanto más rápido de la iteración.

Para una información más completa lista de comparación, ver a mi JSFiddle.

Nota: matriz.reducir es horrible que hay, pero en la Consola de Firebug es más rápido.

Comparar Las Estructuras

Empecé un JSPerf de una matriz de sumatorias. Rápidamente se construye y no se garantiza que sea completa o precisa, pero eso es lo que editar es para 🙂

Mientras que la búsqueda por el mejor método de suma de una matriz, escribí una prueba de rendimiento.

En Chrome, «reducir» parece ser muy superior

Espero que esto ayude a

//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 ms

bucle: 255.000 ms

reducir: 70.000 ms

mientras: 214.000 ms

O se puede hacer el mal camino.

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

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

😉

La forma más rápida de bucle, de acuerdo a esta prueba es un bucle while en el reverso

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

Así, este código puede ser el más rápido usted puede conseguir

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

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

    return total;
}

Array.prototype.sum agrega una suma método a la clase array… que fácilmente podría hacer que una función auxiliar en su lugar.

Para su caso específico, sólo tiene que utilizar el reduce método de Matrices:

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]) );

Basado en esta prueba (para-vs-forEach-vs-reducir) y este (bucles)

Puedo decir que:

1# Rápido: bucle for

var total = 0;

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

2# Agregado

Para usted en caso de que usted no necesita esto, sino que se añade una gran cantidad de flexibilidad.

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;
};

Uso:

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

Concluyentes métodos

Luego viene forEach y reduce que tienen casi el mismo rendimiento y varía de un navegador a otro, pero tienen el peor desempeño de todos modos.

uno de los más simple, más rápido, más reutilizable y flexible es:

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

Lo que acerca de sumar ambas extremidades? Se reduciría a la mitad del tiempo. Así:

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

2, 3, 4, 5, 6, 7; suma = 10

3, 4, 5, 6; suma = 19

4, 5; suma = 28

suma = 37

Un algoritmo puede ser:

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
}

Se realiza más rápido cuando la pruebo en el navegador con performance.now().
Creo que esta es una mejor manera. ¿Ustedes qué piensan?