Berechnen
calc ist eine asynchrone Funktion, die wir analysieren möchten (Leistungsanalyse). Sein letzter Parameter ist ein callback . Wir verwenden calc so:
Calc (arg, (err, res) => console.log (err || res))
Der vielleicht einfachste Weg, die Leistung auf einer Funktion wie calc zu analysieren, besteht darin, eine Zeitlogik hinzuzufügen, wo wir analysieren müssen:
const t0 = date.now () calc (arg, (err, res) => {const t1 = date.now () console.log (`log: Uhrzeit: $ {t1 = t0}`) console.log (err || res)}) Dies ist jedoch keine wiederverwendbare Lösung. Jedes Mal, wenn wir eine Funktion messen möchten, müssen wir einen T0 in den äußeren Bereich einführen und callback ändern, um die Zeit zu messen und aufzunehmen.
Die ideale Möglichkeit für mich besteht darin, es nur durch Wickeln einer asynchronen Funktion zu Zeiten:
Timeit (Calc) (arg, (err, res) => console.log (err || res))
timeIt muss in der Lage sein, die Analyse- und Aufzeichnungsausführungszeit für jede asynchrone Funktion gut durchzuführen.
Beachten Sie, dass timeIt(calc) die gleiche Funktionssignatur wie die ursprüngliche CALC -Funktion hat, dh die gleichen Parameter akzeptieren und den gleichen Wert zurückgeben. Es fügt dem CALE nur eine Funktion hinzu (eine Funktion, die die Zeit aufgezeichnet werden kann).
Calc und Timeit (CALC) können jederzeit durch einander ersetzt werden.
timeIt selbst ist eine Funktion höherer Ordnung, da sie eine Funktion akzeptiert und eine Funktion zurückgibt. In unserem Beispiel akzeptiert es eine CALC -Asynchronfunktion und gibt eine Funktion mit denselben Parametern und dem Rückgabewert wie Calc zurück.
Das Folgende zeigt, wie wir die Zeititfunktion implementieren:
const timeit = r.curry ((Bericht, f) => (... args) => {const t0 = Datum.Now () const nargs = R.Init (args) const radback = r.last (args) nargs.push ((... Args) => {const t1 = Datum.Now () CALLBACK (... MIT) melden (... t1 - t1 - t1 - t1 - t1 - t1 - t0, ...) f (... nargs)}) const timeit1 = timeit ((t, err, res) => console.log (`log: $ {err || res} produziert nach: $ {t}`) const calc = (x, y, z, callback) => setTimeout () => callback (null, x * y / z), 1000). console.log (err || res)) Zeitit1 (Calc) (18, 7, 3, (err, res) => console.log (err || res)) Diese timeIt akzeptiert zwei Parameter:
Bericht: Eine Funktion wird verwendet, um Analyseergebnisse zu generieren
F: Asynchrone Funktion Wir möchten eine Analyse durchführen
timeIt1 ist eine bequeme und praktische Funktion. Sie verwendet nur console.log um Zeitmessergebnisse aufzuzeichnen. Wir definieren es, indem wir report an die allgemeinere timeIt übergeben.
Wir haben das Ziel erreicht, und jetzt können wir die asynchrone Funktion in timeIt1 und der Zeit einwickeln, die zeitlich festgelegt ist:
Timeit1 (Calc) (18, 7, 3, (err, res) => console.log (err || res))
Die allgemeine timeIt empfängt eine report -Rückruffunktion und eine asynchrone Funktion und gibt eine neue asynchrone Funktion zurück. Diese asynchrone Funktion hat die gleichen Parameter und den gleichen Rückgabewert wie die ursprüngliche Funktion. Wir können dies verwenden:
Timeit ((Zeit, ... Ergebnis) => // Rückruf melden: Loggen Sie die Zeit, asyncfunc) (Parameter…, (... Ergebnis) => // Ergebnis der asynchronisierten Funktion)
Lassen Sie uns nun in die Umsetzung von timeIt eintauchen. Wir können einfach eine allgemeine Funktion wie timeIt1 erzeugen, da timeIt mit R.curry koryliert wird.
Ich habe nicht vor, die Korikulisierung in diesem Beitrag zu diskutieren, aber der folgende Code zeigt die Hauptverwendung der Korikulisierung:
const f = r.curry ((x, y) => x + y) f (1, 10) // == 11f (1) (10) // == 11Const plus1 = f (1) plus1 (10) // == 11
Auf der anderen Seite werden auf diese Weise mehrere Probleme mit dem Zeitpunkt implementiert:
(... args) => {const t1 = date.now () callback (... args) report (t1 - t0, ... args)} Dies ist eine anonyme Funktion (auch als Lambda bekannt), die nach der asynchronen Ausführung der ursprünglichen Funktion aufgerufen wird. Das Hauptproblem ist, dass diese Funktion keinen Mechanismus hat, um Ausnahmen zu bewältigen. Wenn callback eine Ausnahme ausgelöst wird, wird report niemals aufgerufen.
Wir können dieser lambda -Funktion einen try / catch hinzufügen, aber das Problem ist, dass callback und report zwei void -Funktionen sind und nicht zugeordnet sind. timeIt enthält zwei Kontinuationen ( report und callback ). Wenn wir nur die Ausführungszeit unter console aufzeichnen oder sicher sind, dass weder report noch callback Ausnahmen veröffentlichen, ist alles in Ordnung. Wenn wir jedoch ein gewisses Verhalten auf der Grundlage der Analyseergebnisse (sogenannte automatische Skalierung) ausführen möchten, müssen wir die Fortsetzung der Fortsetzung in unserem Programm stärken und klären.
Okay, ich hoffe, der vollständige Inhalt dieses Artikels wird für das Studium und die Arbeit aller hilfreich sein. Wenn Sie Fragen haben, können Sie eine Nachricht zur Kommunikation überlassen.