Warum ist lodash.each für jeden schneller als native?

Ich habe versucht, den schnellsten Weg zu finden, um eine for-Schleife mit einem eigenen Bereich auszuführen. Die drei Methoden, die ich verglichen habe, waren:

var a = "t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t".split();

// lodash .each -> 1,294,971 ops/sec
lodash.each(a, function(item) { cb(item); });

// native .forEach -> 398,167 ops/sec
a.forEach(function(item) { cb(item); });

// native for -> 1,140,382 ops/sec
var lambda = function(item) { cb(item); };
for (var ix = 0, len = a.length; ix < len; ix++) {
  lambda(a[ix]);
}

Dies ist unter Chrome 29 unter OS X. Sie können die Tests hier selbst ausführen:

http://jsben.ch/BQhED

Wie ist Lodash .eachfast doppelt so schnell wie einheimisch .forEach? Und außerdem, wie ist es schneller als die Ebene for? Zauberei? Schwarze Magie?

_.each()ist nicht vollständig kompatibel mit [].forEach(). Siehe folgendes Beispiel:

var a = ['a0'];
a[3] = 'a3';
_.each(a, console.log); // runs 4 times
a.forEach(console.log); // runs twice -- that's just how [].forEach() is specified

http://jsfiddle.net/BhrT3/

Bei der Implementierung von lodash fehlt daher eine if (... in ...)Überprüfung, die den Leistungsunterschied erklären könnte.

Wie in den obigen Kommentaren erwähnt, wird der Unterschied zu native forhauptsächlich durch die zusätzliche Funktionssuche in Ihrem Test verursacht. Verwenden Sie diese Version, um genauere Ergebnisse zu erhalten:

for (var ix = 0, len = a.length; ix < len; ix++) {
  cb(a[ix]);
}

http://jsperf.com/lo-dash-each-vs-native-foreach/15

http://kitcambridge.be/blog/say-hello-to-lo-dash/

Die Lo-Dash-Entwickler erklären (hier und in einem Video), dass die relative Geschwindigkeit des Native forEachzwischen den Browsern variiert. Nur weil forEaches nativ ist, heißt das nicht, dass es schneller ist als eine einfache Schleife, die mit foroder erstellt wurde while. Zum einen forEachmuss sich der mit mehr Sonderfällen befassen. Zweitens forEachwerden Rückrufe mit dem (potenziellen) Overhead des Funktionsaufrufs usw. verwendet.

chromeInsbesondere ist bekannt (zumindest den Lo-Dash-Entwicklern), dass sie relativ langsam sind forEach. Für diesen Browser verwendet lo-dash eine eigene einfache whileSchleife, um an Geschwindigkeit zu gewinnen. Daher der Geschwindigkeitsvorteil, den Sie sehen (andere jedoch nicht).

Durch die intelligente Auswahl nativer Methoden - eine native Implementierung wird nur verwendet, wenn bekannt ist, dass sie in einer bestimmten Umgebung schnell ist - vermeidet Lo-Dash die Leistungskosten und Konsistenzprobleme, die mit nativen Methoden verbunden sind.

Ja, lodash / Unterstrich haben nicht einmal die gleiche Semantik wie .forEach. Es gibt ein subtiles Detail, das die Funktion sehr langsam macht, es sei denn, die Engine kann ohne Getter schnell nach spärlichen Arrays suchen.

Dies ist zu 99% spezifikationskonform und läuft mit der gleichen Geschwindigkeit wie lodash in V8 für den allgemeinen Fall:

function FastAlmostSpecForEach( fn, ctx ) {
    "use strict";
    if( arguments.length > 1 ) return slowCaseForEach();
    if( typeof this !== "object" ) return slowCaseForEach();
    if( this === null ) throw new Error("this is null or not defined");
    if( typeof fn !== "function" ) throw new Error("is not a function");
    var len = this.length;
    if( ( len >>> 0 ) !== len ) return slowCaseForEach();


    for( var i = 0; i < len; ++i ) {
        var item = this[i];
        //Semantics are not exactly the same,
        //Fully spec compliant will not invoke getters
       //but this will.. however that is an insane edge case
        if( item === void 0 && !(i in this) ) {
            continue;
        }
        fn( item, i, this );
    }
}

Array.prototype.fastSpecForEach = FastAlmostSpecForEach;

Indem wir zuerst nach undefiniert suchen, bestrafen wir normale Arrays in der Schleife überhaupt nicht. Eine Engine könnte ihre Interna verwenden, um seltsame Arrays zu erkennen, V8 jedoch nicht.

Hier ist ein aktualisierter Link (ca. 2015), der den Leistungsunterschied zeigt, der alle drei vergleicht for(...), Array.forEachund _.each: https://jsperf.com/native-vs-underscore-vs-lodash

Hinweis: Geben Sie hier ein, da ich noch nicht genügend Punkte hatte, um die akzeptierte Antwort zu kommentieren.