Warum ist die letztere Funktion 10% schneller, obwohl die Variablen immer wieder erstellt werden müssen?

var toSizeString = (function() {

 var KB = 1024.0,
     MB = 1024 * KB,
     GB = 1024 * MB;

  return function(size) {
    var gbSize = size / GB,
        gbMod  = size % GB,
        mbSize = gbMod / MB,
        mbMod  = gbMod % MB,
        kbSize = mbMod / KB;

    if (Math.floor(gbSize)) {
      return gbSize.toFixed(1) + 'GB';
    } else if (Math.floor(mbSize)) {
      return mbSize.toFixed(1) + 'MB';
    } else if (Math.floor(kbSize)) {
      return kbSize.toFixed(1) + 'KB';
    } else {
      return size + 'B';
    }
  };
})();

Und die schnellere Funktion: (Beachten Sie, dass immer wieder die gleichen Variablen kb / mb / gb berechnet werden müssen). Wo gewinnt es Leistung?

function toSizeString (size) {

 var KB = 1024.0,
     MB = 1024 * KB,
     GB = 1024 * MB;

 var gbSize = size / GB,
     gbMod  = size % GB,
     mbSize = gbMod / MB,
     mbMod  = gbMod % MB,
     kbSize = mbMod / KB;

 if (Math.floor(gbSize)) {
      return gbSize.toFixed(1) + 'GB';
 } else if (Math.floor(mbSize)) {
      return mbSize.toFixed(1) + 'MB';
 } else if (Math.floor(kbSize)) {
      return kbSize.toFixed(1) + 'KB';
 } else {
      return size + 'B';
 }
};

Moderne JavaScript-Engines kompilieren allesamt just-in-time. Man kann keine Vermutungen darüber anstellen, was es "immer und immer wieder schaffen muss". Diese Art der Berechnung ist in beiden Fällen relativ einfach zu optimieren.

Andererseits ist das Schließen über konstante Variablen kein typischer Fall, für den Sie die JIT-Kompilierung anstreben würden. In der Regel erstellen Sie einen Abschluss, wenn Sie diese Variablen bei verschiedenen Aufrufen ändern möchten. Sie erstellen auch eine zusätzliche Zeiger-Dereferenzierung, um auf diese Variablen zuzugreifen, z. B. den Unterschied zwischen dem Zugriff auf eine Mitgliedsvariable und ein lokales int in OOP.

Diese Art von Situation ist der Grund, warum die Leute die Linie "vorzeitige Optimierung" streichen. Die einfachen Optimierungen werden bereits vom Compiler durchgeführt.

Variablen sind billig. Ausführungskontexte und Umfangsketten sind teuer.

Es gibt verschiedene Antworten, die im Wesentlichen auf "weil Abschlüsse" hinauslaufen, und diese sind im Wesentlichen wahr, aber das Problem betrifft nicht speziell den Abschluss, sondern die Tatsache, dass Sie eine Funktion haben, die auf Variablen in einem anderen Bereich verweist. Sie hätten das gleiche Problem, wenn dies globale Variablen auf dem wärenwindow Objekt , im Gegensatz zu lokalen Variablen innerhalb des IIFE. Probieren Sie es aus und sehen Sie.

Also in Ihrer ersten Funktion, wenn die Engine diese Anweisung sieht:

var gbSize = size / GB;

Es müssen folgende Schritte ausgeführt werden:

1. Suche nach einer Variablen sizeim aktuellen Bereich. (Fand es.)
2. Suche nach einer Variablen GBim aktuellen Bereich. (Nicht gefunden.)
3. Suchen Sie GBim übergeordneten Bereich nach einer Variablen . (Fand es.)
4. Berechnen und zuweisen gbSize.

Schritt 3 ist erheblich teurer als nur die Zuweisung einer Variablen. Darüber hinaus tun Sie dies fünfmal , einschließlich zweimal für beide GBund MB. Ich vermute, dass, wenn Sie diese zu Beginn der Funktion Alias ​​(zvar gb = GB ) und stattdessen auf den Alias ​​verweisen, dies tatsächlich zu einer geringen Beschleunigung führt, obwohl es auch möglich ist, dass einige JS-Engines diese Optimierung bereits durchführen. Und der effektivste Weg, die Ausführung zu beschleunigen, besteht natürlich darin, die Scope-Kette überhaupt nicht zu durchlaufen.

Beachten Sie, dass JavaScript nicht wie eine kompilierte, statisch typisierte Sprache ist, in der der Compiler diese variablen Adressen zur Kompilierungszeit auflöst. Die JS-Engine muss sie nach Namen auflösen , und diese Suchvorgänge werden jedes Mal zur Laufzeit ausgeführt. Sie sollten sie daher nach Möglichkeit meiden.

Die variable Zuweisung ist in JavaScript extrem günstig. Es könnte tatsächlich die billigste Operation sein, obwohl ich nichts habe, um diese Aussage zu stützen. Trotzdem kann man mit Sicherheit sagen, dass es fast nie eine gute Idee ist, das Erstellen von Variablen zu vermeiden . Fast jede Optimierung, die Sie in diesem Bereich vornehmen, wird die Leistung sogar noch verschlechtern.

Bei einem Beispiel handelt es sich um eine Schließung, bei dem anderen nicht. Das Implementieren von Closures ist etwas knifflig, da Closed-Over-Variablen nicht wie normale Variablen funktionieren. Dies ist in einer einfachen Sprache wie C offensichtlicher, aber ich werde JavaScript verwenden, um dies zu veranschaulichen.

Ein Closure besteht nicht nur aus einer Funktion, sondern auch aus allen Variablen, über die es geschlossen hat. Wenn wir diese Funktion aufrufen möchten, müssen wir auch alle Variablen bereitstellen, die geschlossen sind. Wir können einen Abschluss durch eine Funktion modellieren, die ein Objekt als erstes Argument empfängt, das diese über Variablen geschlossenen Werte darstellt:

function add(vars, y) {
  vars.x += y;
}

function getSum(vars) {
  return vars.x;
}

function makeAdder(x) {
  return { x: x, add: add, getSum: getSum };
}

var adder = makeAdder(40);
adder.add(adder, 2);
console.log(adder.getSum(adder));  //=> 42

Beachten Sie die closure.apply(closure, ...realArgs)dazu erforderliche umständliche Aufrufkonvention

Die integrierte Objektunterstützung von JavaScript ermöglicht es, das explizite varsArgument wegzulassen und thisstattdessen Folgendes zu verwenden :

function add(y) {
  this.x += y;
}

function getSum() {
  return this.x;
}

function makeAdder(x) {
  return { x: x, add: add, getSum: getSum };
}

var adder = makeAdder(40);
adder.add(2);
console.log(adder.getSum());  //=> 42

Diese Beispiele entsprechen dem Code, der tatsächlich Abschlüsse verwendet:

function makeAdder(x) {
  return {
    add: function (y) { x += y },
    getSum: function () { return x },
  };
}

var adder = makeAdder(40);
adder.add(2);
console.log(adder.getSum());  //=> 42

In diesem letzten Beispiel wird das Objekt nur zum Gruppieren der beiden zurückgegebenen Funktionen verwendet. Die thisBindung ist irrelevant. Alle Details zur Ermöglichung von Schließungen - die Übergabe versteckter Daten an die eigentliche Funktion, die Änderung aller Zugriffe auf Schließungsvariablen, um in diesen versteckten Daten nachzuschlagen - werden von der Sprache erledigt.

Das Aufrufen von Closures bedeutet jedoch den Mehraufwand für das Übergeben dieser zusätzlichen Daten, und das Ausführen eines Closures bedeutet den Mehraufwand für das Nachschlagen dieser zusätzlichen Daten - der durch eine schlechte Cache-Lokalität und normalerweise eine Zeiger-Dereferenzierung im Vergleich zu normalen Variablen verschlechtert wird -, so dass dies nicht verwunderlich ist Eine Lösung, die nicht auf Verschlüssen beruht, bietet eine bessere Leistung. Zumal alles, was Sie mit Ihrem Verschluss ersparen, ein paar extrem kostengünstige Rechenoperationen sind, die beim Parsen sogar konstant gefaltet werden können.