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

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.

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)

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

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.

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).

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.

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.

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.

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)

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');

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.

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

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

Es kann Ihnen helfen.

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

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.

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;

});

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')

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.

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

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'

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"
    ]
 }

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

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

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

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');

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).

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)

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