So messen Sie die Zeit, die eine Funktion zur Ausführung benötigt

1192

Ich brauche die Ausführungszeit in Millisekunden.

Ich habe diese Frage ursprünglich im Jahr 2008 gestellt. Die akzeptierte Antwort war dann die Verwendung von new Date (). GetTime () Wir können uns jedoch jetzt alle darauf einigen, dass die Verwendung der Standard- API performance.now () angemessener ist. Ich ändere daher die akzeptierte Antwort auf diese.

Julius A.
quelle
3
Oft kann sich eine Aussage darüber, was Sie mit der Ausführungszeit erreichen möchten, als weitaus nützlicher erweisen, als die Frage allein zu beantworten. Heutzutage ist die Verwendung der Profilerstellung in Firebug- oder Chrome Dev-Tools oft eine weitaus bessere Möglichkeit, den Code zu finden, der Ihren CPU-Saft aufsaugt.
Oligofren
Hier ist, wie Sie es auf klassische DateWeise tun können, was Ihnen gibt msund für die meisten Fälle ausreicht, denke ich, albertech.blogspot.com/2015/07/… ... aber ja, Sie sollten es sich wirklich ansehenPerformance.now
jar
5
performance.now()funktioniert nicht in Node. new Date().getTime()wird in Node funktionieren.
Ryan Walker
1
Nummer 1000 Upvote Woop Woop: D
Kiksen
1
@oligofren - Manchmal möchten Sie diese Daten möglicherweise erfassen. Ich habe eine Situation, in der ich dies an indexedDB
ThomasRones

Antworten:

1758

Verwenden von performance.now () :

var t0 = performance.now()

doSomething()   // <---- The function you're measuring time for 

var t1 = performance.now()
console.log("Call to doSomething took " + (t1 - t0) + " milliseconds.")

NodeJs: Es ist erforderlich, dieperformance Klasse zu importieren


Verwenden von console.time :(nicht standard)( Lebensstandard )

console.time('someFunction')

someFunction() // Whatever is timed goes between the two "console.time"

console.timeEnd('someFunction')

Hinweis :
Die Zeichenfolge, die an dieMethodentime()und übergeben wirdtimeEnd(), muss übereinstimmen
(damit der Timer wie erwartet endet).

console.time() Dokumentationen:

  1. NodeJS-Dokumentation zu
  2. MDN-Dokumentation (clientseitig)
vsync
quelle
27
Es wird jetzt auch von Chrome Developer Tools unterstützt.
julien_c
3
Dies ist derzeit der beste Weg, um genaue Zeitangaben nach meinem Verständnis zu sammeln.
Ash Blue
6
Müssen Sie die Funktion zwischen diesen beiden Anweisungen nicht ausführen? Sie messen jetzt die Zeit, die zum Definieren und nicht zum Ausführen benötigt wird. Korrigieren Sie mich, wenn ich falsch liege ...
Cristian
2
Link zum MDN-Artikel über diese Funktion: developer.mozilla.org/en-US/docs/DOM/console.time
Nullability
6
Ja, Sie können "totalTime + = console.timeEnd (" timer ")" und dies für jeden Timer tun
vsync
637

benutze neues Date (). getTime ()

Die Methode getTime () gibt die Anzahl der Millisekunden seit Mitternacht des 1. Januar 1970 zurück.

Ex.

var start = new Date().getTime();

for (i = 0; i < 50000; ++i) {
// do something
}

var end = new Date().getTime();
var time = end - start;
alert('Execution time: ' + time);
Owen
quelle
9
Beachten Sie, dass Sie den Aufruf getTime () durch + new Date () ersetzen können: var start = + new Date (); // mache Sachen Alarm ("Ausführungszeit:" + (+ neues Datum ()) - Start);
J c
55
Die Timings sind nicht korrekt, da das Datum für diese Funktionalität nicht vorgesehen ist. Ich werde hier mutig sein und sagen, Sie sollten das Beispiel von vsync verwenden, wenn Sie ein genaues Timing wünschen. Obwohl es nur in Chrome und Firefox ATM funktioniert.
Ash Blue
9
Achtung, getMilliseconds () gibt Ihnen den Millisekundenbruchteil der aktuellen Sekunde an. Wenn Sie getTime () durch getMilliseconds () ersetzen, erhalten Sie negative Ergebnisse, wenn Sie eine Sekunde überschreiten.
RickyA
6
Die Antwort von vsync ist nach heutigen Maßstäben weitaus korrekter, und die Verwendung von Date () kann dazu führen, dass sehr fehlerhafte Ergebnisse angezeigt werden, insbesondere auf der Windows-Plattform, auf der die Ergebnisse auf die nächste 15-ms-Grenze gerundet werden können, was zu seltsamen Dingen wie z 0ms Timings auf winzigen Codebits.
Oligofren
29
@AshBlue sollten wir verwenden window.performance.now. Siehe stackoverflow.com/a/15641427/632951
Pacerier
405

Verwenden Sie nicht Date (). Lesen Sie unten.

Verwendungperformance.now() :

<script>
var a = performance.now();
alert('do something...');
var b = performance.now();
alert('It took ' + (b - a) + ' ms.');
</script>

Es funktioniert auf:

  • IE 10 ++

  • FireFox 15 ++

  • Chrome 24 ++

  • Safari 8 ++

  • Opera 15 ++

  • Android 4.4 ++

  • usw. usw.

console.timemag für Sie lebensfähig sein , aber es ist nicht Standard § :

Diese Funktion ist nicht Standard und befindet sich nicht auf einer Standardspur. Verwenden Sie es nicht auf Produktionsstandorten mit Blick auf das Web: Es funktioniert nicht für jeden Benutzer. Es kann auch große Inkompatibilitäten zwischen Implementierungen geben, und das Verhalten kann sich in Zukunft ändern.

Neben der Browserunterstützung performance.nowscheint das Potenzial zu bestehen, genauere Timings bereitzustellen, da es sich anscheinend um die Bare-Bones-Version von handelt console.time.


<rant> Verwenden SieDate es NIEMALS für irgendetwas, da es durch Änderungen der "Systemzeit" beeinflusst wird. Das heißt , wir werden ungültige Ergebnisse -ähnlichen „negatives Timing“ erhalten - wenn der Benutzer nicht eine genaue Systemzeit hat:

Im Oktober 2014 ging meine Systemuhr durcheinander und raten Sie mal ... Ich habe Google Mail geöffnet und alle E-Mails meines Tages "vor 0 Minuten gesendet " gesehen. Und ich hatte gedacht, Google Mail soll von erstklassigen Ingenieuren von Google erstellt werden .......

(Stellen Sie Ihre Systemuhr auf vor einem Jahr ein und gehen Sie zu Google Mail, damit wir alle gut lachen können. Vielleicht haben wir eines Tages eine Hall of Shame für JS Date.)

Die now()Funktion von Google Spreadsheet leidet ebenfalls unter diesem Problem.

Die einzige Zeit, die Sie verwenden, Dateist, wenn Sie dem Benutzer seine Systemuhrzeit anzeigen möchten . Nicht , wenn Sie erhalten möchten die Zeit oder Maßnahme nichts.

Pacerier
quelle
3
Genau das, wonach ich gesucht habe! Ich möchte in der Lage sein, mehrere Male zusammen zu addieren, kann das mit Konsolenzeiten nicht wirklich tun.
Ray
8
Beachten Sie, dass dies in Safari noch nicht unterstützt wird: developer.mozilla.org/en-US/docs/Web/API/Performance.now ()
Akos K
2
Ich verwende Firebug Profile und performance.now () und beide funktionieren gut. Performance.now () bestätigt mein Ergebnis von Profile.
Vincent Jia
2
Funktioniert nicht in meinem größten Hangup, dem IE7 (Firmenkunden). Es ist mir egal, die Leistung in Chrom zu messen, es ist immer blitzschnell.
Nick
2
Dies ist ein besserer Weg als console.time ().
Sanjeev
52

Wenn Sie die Ausführungszeit für Funktionen auf Ihrem lokalen Entwicklungscomputer benötigen , können Sie entweder die Profiling-Tools Ihres Browsers oder Konsolenbefehle wie console.time()und verwenden console.timeEnd().

In allen modernen Browsern sind JavaScript-Profiler integriert. Diese Profiler sollten die genaueste Messung liefern, da Sie Ihren vorhandenen Code nicht ändern müssen, da dies die Ausführungszeit der Funktion beeinträchtigen könnte.

So profilieren Sie Ihr JavaScript:

  • Drücken Sie in Chrome F12 und wählen Sie die Registerkarte Profile und dann JavaScript-CPU-Profil erfassen .
  • Installieren / öffnen Sie in Firefox Firebug und klicken Sie auf die Schaltfläche Profil .
  • Drücken Sie in IE 9+ F12 , klicken Sie auf Skript oder Profiler (abhängig von Ihrer IE-Version).

Alternativ können Sie auf Ihrem Entwicklungscomputer Ihrem Code mit console.time()und Instrumente hinzufügen console.timeEnd(). Diese Funktionen, die in Firefox11 +, Chrome2 + und IE11 + unterstützt werden, berichten über Timer, über die Sie starten / stoppen console.time(). time()Nimmt einen benutzerdefinierten Timernamen als Argument und timeEnd()berichtet dann über die Ausführungszeit seit dem Start des Timers:

function a() {
  console.time("mytimer");
  ... do stuff ...
  var dur = console.timeEnd("myTimer"); // NOTE: dur only works in FF
}

Beachten Sie, dass nur Firefox die verstrichene Zeit im timeEnd()Anruf zurückgibt . Die anderen Browser melden das Ergebnis einfach an die Entwicklerkonsole: Der Rückgabewert von timeEnd()ist undefiniert.

Wenn Sie die Ausführungszeit von Funktionen in freier Wildbahn erhalten möchten , müssen Sie Ihren Code instrumentieren. Sie haben ein paar Möglichkeiten. Sie können die Start- und Endzeiten einfach speichern, indem Sie Folgendes abfragen new Date().getTime():

function a() {
  var start = new Date().getTime();
  ... do stuff ...
  var end = new Date().getTime();
  var dur = end - start;
}

Das DateObjekt hat jedoch nur eine Millisekundenauflösung und wird von Änderungen der Systemuhr eines Betriebssystems beeinflusst. In modernen Browsern gibt es eine bessere Option.

Die bessere Option ist die Verwendung der hochauflösenden Zeit , auch bekannt als window.performance.now(). now()ist Date.getTime()in zweierlei Hinsicht besser als das Traditionelle :

  1. now()ist ein Double mit einer Auflösung von Submillisekunden, das die Anzahl der Millisekunden seit dem Start der Seitennavigation darstellt. Es gibt die Anzahl der Mikrosekunden im Bruchteil zurück (z. B. ein Wert von 1000,123 ist 1 Sekunde und 123 Mikrosekunden).

  2. now()nimmt monoton zu. Dies ist wichtig, da es bei nachfolgenden Anrufen möglicherweise vorwärts oder sogar rückwärts springen Date.getTime()kann . Insbesondere wenn die Systemzeit des Betriebssystems aktualisiert wird (z. B. Atomuhrsynchronisation), wird dies ebenfalls aktualisiert. wird garantiert immer monoton ansteigen, so dass es nicht von der Systemzeit des Betriebssystems beeinflusst wird - es wird immer die Wanduhrzeit sein (vorausgesetzt, Ihre Wanduhr ist nicht atomar ...).Date.getTime()now()

now()kann an fast jedem Ort verwendet werden new Date().getTime(), an dem es + new Datekeine Date.now()gibt. Die Ausnahme ist , dass Dateund now()mal nicht mische, da Dateauf Basis Unix-Epoche (die Anzahl der Millisekunden seit 1970), während now()die Anzahl der Millisekunden seit Ihrer Seite der Navigation gestartet (so ist es viel kleiner als sein Date).

Hier ist ein Beispiel für die Verwendung now():

function a() {
  var start = window.performance.now();
   ... do stuff ...
  var end = window.performance.now();
  var dur = end - start;
}

now()wird in Chrome Stable, Firefox 15+ und IE10 unterstützt. Es gibt auch mehrere Polyfills .

Eine weitere Option zum Messen der Ausführungszeit in freier Wildbahn ist UserTiming . UserTiming verhält sich ähnlich wie console.time()und console.timeEnd(), verwendet jedoch denselben hochauflösenden Zeitstempel wie Sie now()(sodass Sie eine monoton ansteigende Uhr im Submillisekundenbereich erhalten) und speichert die Zeitstempel und die Dauer in der PerformanceTimeline .

UserTiming hat die Konzepte von Markierungen (Zeitstempeln) und Kennzahlen (Dauer). Sie können so viele von beiden definieren, wie Sie möchten, und sie werden in der PerformanceTimeline angezeigt .

Um einen Zeitstempel zu speichern, rufen Sie an mark(startMarkName). Um die Dauer seit Ihrer ersten Markierung zu ermitteln, rufen Sie einfach an measure(measurename, startMarkname). Die Dauer wird dann in der PerformanceTimeline neben Ihren Markierungen gespeichert.

function a() {
  window.performance.mark("start");
  ... do stuff ...
  window.performance.measure("myfunctionduration", "start");
}

// duration is window.performance.getEntriesByName("myfunctionduration", "measure")[0];

UserTiming ist in IE10 + und Chrome25 + verfügbar. Es gibt auch eine Polyfüllung (die ich geschrieben habe).

NicJ
quelle
1
Ausgezeichnete und aktuellste Antwort IMHO :) Es wäre noch besser mit ein bisschen Bearbeitung. Ich würde sagen, dass das User-Timing nicht "eine andere Option" für die Messung ist, sondern die bevorzugte Option, wenn das Benchmarking nicht auf dem Entwicklungscomputer selbst durchgeführt wird. Mit Ihrer Polyfill funktioniert es in allen Browsern. Und die Details und das Boilerplate von zu verstecken performance.nowund Dateist der Grund, warum es existiert.
Hashchange
34

Um genaue Werte zu erhalten, sollten Sie die Leistungsschnittstelle verwenden . Es wird in modernen Versionen von Firefox, Chrome, Opera und IE unterstützt. Hier ist ein Beispiel, wie es verwendet werden kann:

var performance = window.performance;
var t0 = performance.now();
doWork();
var t1 = performance.now();
console.log("Call to doWork took " + (t1 - t0) + " milliseconds.")

Date.getTime()oder console.time()sind nicht gut für die Messung der genauen Ausführungszeit. Sie können sie verwenden, wenn eine schnelle grobe Schätzung für Sie in Ordnung ist. Mit groben Schätzungen meine ich, dass Sie eine Verschiebung von 15-60 ms von der Echtzeit erhalten können.

Überprüfen Sie diesen brillanten Beitrag zum Messen der Ausführungszeit in JavaScript. Der Autor gibt auch ein paar Links über die Genauigkeit der JavaScript-Zeit, die es wert sind, gelesen zu werden.

Varvara Kalinina
quelle
Sehr gute Antwort! Das hat mir sehr geholfen!
Kombinieren Sie den
18

Verwenden Sie Firebug, aktivieren Sie sowohl Console als auch Javascript. Klicken Sie auf Profil. Neu laden. Klicken Sie erneut auf Profil. Zeigen Sie den Bericht an.

Stefan Mai
quelle
8
Guter Rat, funktioniert aber offensichtlich nur für FF. Wir wollen oft die Browsergeschwindigkeiten vergleichen ... :-)
PhiLho
3
Bei neuem Firebuq verbergen sie diese Optionen im Menü. Verwenden Sie STRG + UMSCHALT + P oder console.profile (). console..profileEnd ()
user956584
4
Chrome unterstützt console.time()und console.timeEnd()jetzt auch.
Julien_c
12
var StopWatch = function (performance) {
    this.startTime = 0;
    this.stopTime = 0;
    this.running = false;
    this.performance = performance === false ? false : !!window.performance;
};

StopWatch.prototype.currentTime = function () {
    return this.performance ? window.performance.now() : new Date().getTime();
};

StopWatch.prototype.start = function () {
    this.startTime = this.currentTime();
    this.running = true;
};

StopWatch.prototype.stop = function () {
    this.stopTime = this.currentTime();
    this.running = false;
};

StopWatch.prototype.getElapsedMilliseconds = function () {
    if (this.running) {
        this.stopTime = this.currentTime();
    }

    return this.stopTime - this.startTime;
};

StopWatch.prototype.getElapsedSeconds = function () {
    return this.getElapsedMilliseconds() / 1000;
};

StopWatch.prototype.printElapsed = function (name) {
    var currentName = name || 'Elapsed:';

    console.log(currentName, '[' + this.getElapsedMilliseconds() + 'ms]', '[' + this.getElapsedSeconds() + 's]');
};

Benchmark

var stopwatch = new StopWatch();
stopwatch.start();

for (var index = 0; index < 100; index++) {
    stopwatch.printElapsed('Instance[' + index + ']');
}

stopwatch.stop();

stopwatch.printElapsed();

Ausgabe

Instance[0] [0ms] [0s]
Instance[1] [2.999999967869371ms] [0.002999999967869371s]
Instance[2] [2.999999967869371ms] [0.002999999967869371s]
/* ... */
Instance[99] [10.999999998603016ms] [0.010999999998603016s]
Elapsed: [10.999999998603016ms] [0.010999999998603016s]

performance.now () ist optional - übergeben Sie einfach false an die StopWatch-Konstruktorfunktion.

kayz1
quelle
12

process.hrtime () ist in Node.js verfügbar - es gibt einen Wert in Nanosekunden zurück

var hrTime = process.hrtime()
console.log(hrTime[0] * 1000000 + hrTime[1] / 1000)
Achim Koellner
quelle
1
Wenn Sie es lieber in ms e-3 als in die vorgeschlagene Mikrosekunde e-6 konvertieren: hrtime[0] * 1000 + hrtime[1] / 1000000-> Ja, ich verwende es auch lieber var hrtime! : P
Cregox
11

Sie können den Operator add auch hier verwenden

 var start = +new Date();
 callYourFunctionHere();
 var end = +new Date();
 var time = end - start;
 console.log('total execution time = '+ time + 'ms');
Alok Deshwal
quelle
8

Verwenden Sie diesen kleinen Code, um den Code von vsync weiter zu erweitern und das timeEnd als Wert in NodeJS zurückzugeben.

console.timeEndValue = function(label) { // Add console.timeEndValue, to add a return value
   var time = this._times[label];
   if (!time) {
     throw new Error('No such label: ' + label);
   }
   var duration = Date.now() - time;
   return duration;
};

Verwenden Sie nun den Code wie folgt:

console.time('someFunction timer');

someFunction();

var executionTime = console.timeEndValue('someFunction timer');
console.log("The execution time is " + executionTime);


Dies gibt Ihnen mehr Möglichkeiten. Sie können die Ausführungszeit speichern, die für andere Zwecke verwendet werden soll, z. B. für die Verwendung in Gleichungen oder in einer Datenbank, die über Websockets an einen Remoteclient gesendet, auf einer Webseite usw. bereitgestellt wird.

Levi Roberts
quelle
8

Es kann nur eine Variable verwendet werden:

var timer = -performance.now();

// Do something

timer += performance.now();
console.log("Time: " + (timer/1000).toFixed(5) + " sec.")

timer/1000 - um Millisekunden in Sekunden umzuwandeln

.toFixed(5) - um zusätzliche Ziffern zu kürzen

user1032559
quelle
5

Da console.timeund performance.nownicht in einigen gängigen Browsern (dh IE10) unterstützt werden, habe ich ein schlankes Programm , das die besten verfügbaren Methoden verwendet. Es fehlt jedoch die Fehlerbehandlung für falsche Verwendungen (Aufrufen End()eines nicht initialisierten Timers).

Verwenden Sie es und verbessern Sie es, wie Sie wollen.

Performance: {
    Timer: {},
    Start: function (name) {
        if (console && console.time) {
            console.time(name);
        } else if (window.performance.now) {
            this.Timer[name] = window.performance.now();
        } else {
            this.Timer[name] = new Date().getTime();
        }
    },
    End: function (name) {
        if (console && console.time) {
            console.timeEnd(name);
        } else {
            var result;
            if (window.performance.now) {
                result = window.performance.now() - this.Timer[name];
            } else {
                result = new Date().getTime() - this.Timer[name];
            }
            console.log(name + ": " + result);
        }
    }
}
Mx.
quelle
5

Es kann Ihnen helfen.

var t0 = date.now(); doSomething(); var t1 = date.now(); console.log("Call to doSomething took approximate" + (t1 - t0)/1000 + " seconds.")

Wajeeh Aslam
quelle
1
Während dieses Code-Snippet die Frage lösen kann, hilft eine Erklärung wirklich, die Qualität Ihres Beitrags zu verbessern. Denken Sie daran, dass Sie die Frage für Leser in Zukunft beantworten und diese Personen möglicherweise die Gründe für Ihren Codevorschlag nicht kennen. Bitte versuchen Sie auch, Ihren Code nicht mit erklärenden Kommentaren zu überfüllen. Dies verringert die Lesbarkeit sowohl des Codes als auch der Erklärungen!
Filnor
5

Hier ist ein Dekorator für Timing-Funktionen

let timed = (f) => (...args)=>{
    let start = performance.now();
    let ret = f(...args);
    console.log(`function ${f.name} took ${(performance.now()-start).toFixed(3)}ms`)
    return ret;   
}

Verwendungszweck:

let test = ()=>{/*does something*/}
test = timed(test)   // turns the function into a timed function in one line
test()               // run your code as normal, logs 'function test took 1001.900ms' 

Wenn Sie asynchrone Funktionen verwenden, können Sie timedasynchronisieren und ein awaitvor f (... args) hinzufügen , und das sollte für diese funktionieren. Es wird komplizierter, wenn ein Dekorateur sowohl Synchronisierungs- als auch Asynchronisierungsfunktionen ausführen soll.

aljgom
quelle
Genau das habe ich gesucht. Vielen Dank!
Andrew Watters
Gibt es eine Möglichkeit, die Verwendung mit asynchronen Funktionen universell zu gestalten?
TotalAMD
4

Danke, Achim Koellner, wird Ihre Antwort ein wenig erweitern:

var t0 = process.hrtime();
//Start of code to measure

//End of code
var timeInMilliseconds = process.hrtime(t0)[1]/1000000; // dividing by 1000000 gives milliseconds from nanoseconds

Bitte beachten Sie, dass Sie nichts anderes tun sollten als das, was Sie messen möchten (z. B. console.logdauert die Ausführung auch einige Zeit und wirkt sich auf Leistungstests aus).

Beachten Sie, dass Sie, um die Ausführungszeit für asynchrone Funktionen zu messen, var timeInMilliseconds = process.hrtime(t0)[1]/1000000;in den Rückruf einfügen sollten . Zum Beispiel,

var t0 = process.hrtime();
someAsyncFunction(function(err, results) {
var timeInMilliseconds = process.hrtime(t0)[1]/1000000;

});
Andrew Marin
quelle
3

Vor ein paar Monaten habe ich meine eigene Routine zusammengestellt, die eine Funktion mit Date.now () mal erstellt - obwohl zu der Zeit die akzeptierte Methode performance.now () zu sein schien -, weil das Performance-Objekt noch nicht verfügbar ist (erstellt) -in) in der stabilen Version von Node.js.

Heute habe ich etwas mehr recherchiert und eine andere Methode für das Timing gefunden. Da ich auch herausgefunden habe, wie man dies in Node.js Code verwendet, dachte ich, ich würde es hier teilen.

Folgendes wird aus den Beispielen von w3c und Node.js kombiniert :

function functionTimer() {
    performance.mark('start')
    functionToBeTimed()
    performance.mark('end')
    performance.measure('Start to End', 'start', 'end')
    const measure = performance.getEntriesByName('Start to End')[0]
    console.log(measure.duration)
}

HINWEIS:

Wenn Sie das performanceObjekt in einer Node.js-App verwenden möchten, müssen Sie Folgendes angeben: const { performance } = require('perf_hooks')

Jonathan Chasteen
quelle
Ich denke, Sie brauchen performance.mark('end')in diesem Fall nicht
Kofifus
3

Es gibt mehrere Möglichkeiten, um dieses Ziel zu erreichen:

  1. mit console.time

    console.time('function');
    //run the function in between these two lines for that you need to 
    //measure time taken by the function. ("ex. function();")
    console.timeEnd('function');
  2. Dies ist der effizienteste Weg: Verwenden von performance.now () , z

    var v1 = performance.now();
    //run the function here for which you have top measure the time 
    var v2 = performance.now();
    console.log("total time  taken = "+(v2-v1)+"milliseconds");
  3. benutze + (Operator hinzufügen) oder getTime ()

    var h2 = +new Date(); //or
    var h2 = new Date().getTime();
    for(i=0;i<500;i++) { /* do something */}
    var h3 = +new Date();   //or 
    var h3 = new Date().getTime();
    var timeTaken = h3-h2;
    console.log("time ====", timeTaken);

Folgendes passiert, wenn Sie den unären Plus-Operator auf eine Datumsinstanz anwenden: Abrufen des Werts der betreffenden Datumsinstanz Konvertieren Sie ihn in eine Zahl

HINWEIS: Bietet getTime()eine bessere Leistung als der unäre + Operator.

Rohit Jaiswal
quelle
1
export default class Singleton {

  static myInstance: Singleton = null;

  _timers: any = {};

  /**
   * @returns {Singleton}
   */
  static getInstance() {
    if (Singleton.myInstance == null) {
      Singleton.myInstance = new Singleton();
    }

    return this.myInstance;
  }

  initTime(label: string) {
    this._timers[label] = Date.now();
    return this._timers[label];
  }

  endTime(label: string) {
    const endTime = Date.now();
    if (this._timers[label]) {
      const delta = endTime - this._timers[label];
      const finalTime = `${label}: ${delta}ms`;
      delete this._timers[label];
      return finalTime;
    } else {
      return null;
    }
  }
}

InitTime im Zusammenhang mit string.

return Singleton.getInstance().initTime(label); // Returns the time init

return Singleton.getInstance().endTime(label); // Returns the total time between init and end

jose920405
quelle
1

Wenn Sie die Zeit zwischen mehreren Dingen messen möchten, die nicht verschachtelt sind, können Sie Folgendes verwenden:

function timer(lap){ 
    if(lap) console.log(`${lap} in: ${(performance.now()-timer.prev).toFixed(3)}ms`); 
    timer.prev = performance.now();
}

Ähnlich wie console.time (), jedoch einfacher zu verwenden, wenn Sie frühere Timer nicht nachverfolgen müssen.

Wenn Ihnen die blaue Farbe von console.time () gefällt, können Sie stattdessen diese Zeile verwenden

console.log(`${lap} in: %c${(performance.now()-timer.prev).toFixed(3)}ms`, 'color:blue');

// Usage: 
timer()              // set the start
// do something 
timer('built')       // logs 'built in: 591.815ms'
// do something
timer('copied')      // logs 'copied in: 0.065ms'
// do something
timer('compared')    // logs 'compared in: 36.41ms'
aljgom
quelle
1

In meinem Fall bevorzuge ich @ grammar suger und kompiliere es mit babel.
Das Problem dieser Methode ist, dass sich die Funktion innerhalb des Objekts befinden muss.

Beispiel für einen JS-Code

function timer() {
    return (target, propertyKey, descriptor) => {
        const start = Date.now();
        let oldFunc = descriptor.value;

        descriptor.value = async function (){
            var result = await oldFunc.apply(this, arguments);
            console.log(Date.now() - start);
            return result;
        }
    }
}

// Util function 
function delay(timeout) {
    return new Promise((resolve) => setTimeout(() => {
        resolve();
    }, timeout));
}

class Test {
    @timer()
    async test(timout) {
        await delay(timout)
        console.log("delay 1");
        await delay(timout)
        console.log("delay 2");
    }
}

const t = new Test();
t.test(1000)
t.test(100)

.babelrc (für babel 6)

 {
    "plugins": [
        "transform-decorators-legacy"
    ]
 }
Yu Huang
quelle
1

Stoppuhr mit kumulativen Zyklen

Funktioniert mit Server und Client (Knoten oder DOM), verwendet die PerformanceAPI. Gut, wenn Sie viele kleine Zyklen haben, z. B. in einer 1000-mal aufgerufenen Funktion, die 1000 Datenobjekte verarbeitet, aber Sie möchten sehen, wie sich jede Operation in dieser Funktion zur Gesamtsumme summiert.

Dieser verwendet also einen globalen (Singleton-) Timer für Module. Wie ein Klassen-Singleton-Muster, nur etwas einfacher zu verwenden, aber Sie müssen dies in einer separaten zB stopwatch.jsDatei ablegen.

const perf = typeof performance !== "undefined" ? performance : require('perf_hooks').performance;
const DIGITS = 2;

let _timers = {};

const _log = (label, delta?) => {
    if (_timers[label]) {
        console.log(`${label}: ` + (delta ? `${delta.toFixed(DIGITS)} ms last, ` : '') +
            `${_timers[label].total.toFixed(DIGITS)} ms total, ${_timers[label].cycles} cycles`);
    }
};

export const Stopwatch = {
    start(label) {
        const now = perf.now();
        if (_timers[label]) {
            if (!_timers[label].started) {
                _timers[label].started = now;
            }
        } else {
            _timers[label] = {
                started: now,
                total: 0,
                cycles: 0
            };
        }
    },
    /** Returns total elapsed milliseconds, or null if stopwatch doesn't exist. */
    stop(label, log = false) {
        const now = perf.now();
        if (_timers[label]) {
            let delta;
            if(_timers[label].started) {
                delta = now - _timers[label].started;
                _timers[label].started = null;
                _timers[label].total += delta;
                _timers[label].cycles++;
            }
            log && _log(label, delta);
            return _timers[label].total;
        } else {
            return null;
        }
    },
    /** Logs total time */
    log: _log,
    delete(label) {
        delete _timers[label];
    }
};
gombosg
quelle
1

Der beste Weg wäre, das performance hooksModul zu verwenden. Obwohl instabil, können Sie markbestimmte Bereiche Ihres Codes und measuredie durationzwischen markierten Bereiche festlegen.

const { performance, PerformanceObserver } = require('perf_hooks');

const measures = []

const obs = new PerformanceObserver(list => measures.push(...list.getEntries()));
obs.observe({ entryTypes: ['measure'] });
const getEntriesByType = cb => cb(measures);

const doSomething = val => {
  performance.mark('beginning of the process');

  val *= 2;

  performance.mark('after multiplication');

  performance.measure('time taken', 'beginning of the process', 'after multiplication');

  getEntriesByType(entries => {
    entries.forEach(entry => console.log(entry));
  })

  return val;
}

doSomething(4);

Versuchen Sie es hier

toondaey
quelle
0
const { performance } = require('perf_hooks');

function addUpTo(n) {
  let total = 0;
  for (let i = 1; i <= n; i++) {
    total += i;
  }
  return total;
}


let t1 = performance.now();
addUpTo(1000000000);
let t2 = performance.now();
console.log(`Time elapsed: ${(t2 - t1) / 1000} seconds`);
// Time elapsed: 1.1261566010713577 seconds
Homam Bahrani
quelle
0

Mit Leistung

NodeJs: Es ist erforderlich, die Leistungsklasse zu importieren

var time0 = performance.now(); // Store the time at this point into time0

yourFunction();   // The function you're measuring time for 

var time1 = performance.now(); // Store the time at this point into time1

console.log("youFunction took " + (time1 - time0) + " milliseconds to execute");

Verwenden von console.time

console.time('someFunction');

someFunction(); // Whatever is timed goes between the two "console.time"

console.timeEnd('someFunction');
iCPSoni
quelle
0
  1. Verwenden Sie zum Starten des Timersconsole.time("myTimer");
  2. Optional: Verwenden Sie zum Drucken der verstrichenen Zeit console.timeLog("myTimer");
  3. So stoppen Sie den Timer und drucken die letzte Zeit:console.timeEnd("myTimer");

Weitere Informationen hierzu finden Sie auf MDN und in der Node.js-Dokumentation .

Verfügbar für Chrome, Firefox, Opera und NodeJS. (nicht auf Edge oder Internet Explorer).

bvdb
quelle
-2

Wie bereits erwähnt, prüfen und verwenden Sie den eingebauten Timer. Aber wenn Sie hier Ihre eigenen schreiben wollen oder müssen, sind meine zwei Cent:

//=-=|Source|=-=//
/**
 * JavaScript Timer Object
 *
 *      var now=timer['elapsed'](); 
 *      timer['stop']();
 *      timer['start']();
 *      timer['reset']();
 * 
 * @expose
 * @method timer
 * @return {number}
 */
timer=function(){
    var a=Date.now();
    b=0;
    return{
        /** @expose */
        elapsed:function(){return b=Date.now()-a},
        start:function(){return a=Date.now()},
        stop:function(){return Date.now()},
        reset:function(){return a=0}
    }
}();

//=-=|Google Advanced Optimized|=-=//
timer=function(){var a=Date.now();b=0;return{a:function(){return b=Date.now()-a},start:function(){return a=Date.now()},stop:function(){return Date.now()},reset:function(){return a=0}}}();

Die Zusammenstellung war ein Erfolg!

  • Originalgröße: 219 Bytes gezippt (405 Bytes unkomprimiert)
  • Kompilierte Größe: 109 Bytes gezippt (187 Bytes unkomprimiert)
  • 50,23% weniger als die komprimierte Größe (53,83% ohne gzip)
NlaakALD
quelle
-6

Die akzeptierte Antwort ist falsch !

Da JavaScript asynchron ist, wären die Werte des variablen Endes der akzeptierten Antwort falsch.

var start = new Date().getTime();

for (i = 0; i < 50000; ++i) {
// JavaScript is not waiting until the for is finished !!
}

var end = new Date().getTime();
var time = end - start;
alert('Execution time: ' + time); 

Die Ausführung von for kann sehr schnell sein, sodass Sie nicht sehen können, dass das Ergebnis falsch ist. Sie können es mit einem Code testen, der eine Anfrage ausführt:

var start = new Date().getTime();

for (i = 0; i < 50000; ++i) {
  $.ajax({
    url: 'www.oneOfYourWebsites.com',
    success: function(){
       console.log("success");
    }
  });
}

var end = new Date().getTime();
var time = end - start;
alert('Execution time: ' + time); 

Die Warnung wird also sehr schnell angezeigt, aber in der Konsole sehen Sie, dass die Ajax-Anforderungen fortgesetzt werden.

So sollten Sie es tun: https://developer.mozilla.org/en-US/docs/Web/API/Performance.now

Mirza Selimovic
quelle
9
Es liegt nicht an der for-Schleife. Eine for-Schleife wartet bis zur letzten Schleife, bis sie im Quellcode weitergeht. AJAX-Aufrufe sind asynchron. Und es gibt auch andere Funktionen, die asynchron ausgeführt werden. Eine for-Schleife ist jedoch nicht asynchron ausgeführt.
Scriptlabs