wake-up-neo.net

Schnellste JavaScript-Zusammenfassung

Was ist der schnellste Weg, ein Array in JavaScript zusammenzufassen? Eine schnelle Suche wird umgedreht ein paar verschiedene Methoden , aber ich hätte gerne eine native Lösung. Dies wird unter SpiderMonkey ausgeführt. 

Ich denke im Inneren der Box nach:

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

Ich bin sicher, es gibt einen besseren Weg als eine direkte Iteration. 

60
Josh K

Sie sollten reduce verwenden können.

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

Quelle

Und mit den in ES6 eingeführten Pfeilfunktionen ist es noch einfacher:

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

Verbesserungen


Ihre Schleifenstruktur könnte schneller gemacht werden:


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

Dadurch wird array.length einmal und nicht bei jeder Iteration abgerufen. Die Optimierung erfolgt durch Zwischenspeichern des Werts.


Wenn Sie es wirklich beschleunigen wollen:


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

Dies entspricht einer while-Reverse-Schleife. Der Wert wird zwischengespeichert und mit 0 verglichen, wodurch die Iteration beschleunigt wird.

Eine vollständigere Vergleichsliste finden Sie in meinem JSFiddle.
Hinweis: array.reduce ist dort schrecklich, in Firebug Console jedoch am schnellsten.


Strukturen vergleichen

Ich habe ein JSPerf für Array-Summierungen gestartet. Es wurde schnell erstellt und es kann nicht garantiert werden, dass es vollständig oder genau ist, aber dafür ist edit gedacht :)

30
vol7ron

Bei der Suche nach der besten Methode zum Summieren eines Arrays schrieb ich einen Leistungstest.

In Chrome scheint "Reduzieren" weit überlegen zu sein

Ich hoffe das hilft

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

schleife: 255.000 ms

reduzieren: 70.000ms

während: 214.000 ms

19
Inkh Su Tesou

Die schnellste Schleife ist laut diesem Test eine umgekehrte Schleife

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

Daher könnte dieser Code der schnellste sein, den Sie bekommen können

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

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

    return total;
}

Array.prototype.sum fügt der Array-Klasse eine summenmethode hinzu.

5
CaffGeek

Oder du könntest es auf böse Weise tun.

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

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

;)

3
Kodejuice

Verwenden Sie für Ihren speziellen Fall einfach die reduce-Methode von Arrays:

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]) );
2
Tim Down

Basierend auf diesem Test (for-vs-forEach-vs-reduz) und this (Schleifen)

Ich kann das sagen:

1 # Am schnellsten: für Schleife

var total = 0;

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

2 # Aggregat

Für Sie brauchen Sie das zwar nicht, aber es gibt viel Flexibilität.

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

Verwendungszweck:

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

Nicht schlüssige Methoden

Dann kommen forEach und reduce, die fast die gleiche Leistung haben und von Browser zu Browser unterschiedlich sind, aber sie haben sowieso die schlechteste Leistung.

1
BrunoLM

Wie sieht es mit dem Summieren beider Extremitäten aus? Das würde die Zeit halbieren. So wie:

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

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

3, 4, 5, 6; Summe = 19

4, 5; Summe = 28

summe = 37

Ein Algorithmus könnte sein:

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
}

Es ist schneller, wenn ich es mit performance.now()..__ im Browser teste. Ich denke, das ist ein besserer Weg. Was denkt ihr?

0
cesarvargas

eine der einfachsten, schnellsten, wiederverwendbaren und flexiblen Lösungen ist:

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