Wie misst man die Zeit, die eine Funktion zur Ausführung benötigt?

verwenden Sie new 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.

Verwende performance.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 ++

• etc, etc

console.time kann für Sie lebensfähig sein , aber es ist nicht standardisiert § :

Diese Funktion ist keine Standardfunktion 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.

Abgesehen von der Browserunterstützung scheint performance.now das Potenzial zu haben , genauere Timings zu liefern, da es sich anscheinend um die Bare-Bones-Version von console.time handelt.

<rant> Verwenden Sie auch NIEMALS Date für alles , da es betroffen ist durch Änderungen in der "Systemzeit". Das bedeutet, dass wir ungültige Ergebnisse erhalten - wie "negatives Timing" - wenn der Benutzer keine genaue Systemzeit hat:

Im Oktober 2014 ging meine Systemuhr durcheinander und erraten, was .... Ich öffnete Gmail und sah alle E-Mails meines Tages msgstr "gesendet vor 0 Minuten ". 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 Funktion now() in Google Spreadsheet ist ebenfalls von diesem Problem betroffen.

Das einzige Mal, dass Sie Date verwenden, ist, wenn Sie dem Benutzer seine Systemuhrzeit anzeigen möchten. Nicht, wenn Sie die Zeit ​​erhalten oder irgendetwas messen möchten.

Wenn Sie die Ausführungszeit für Funktionen auf Ihrem lokalen Entwicklungscomputer benötigen , können Sie entweder die Profilerstellungstools Ihres Browsers oder Konsolenbefehle wie console.time() und 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, was sich auf die Ausführungszeit der Funktion auswirken könnte.

So profilieren Sie Ihr JavaScript:

• Drücken Sie in Chrome F12 und wählen Sie die Registerkarte Profile und dann JavaScript sammeln] CPU-Profil.
• 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 console.timeEnd() Instrumentierung hinzufügen . Diese Funktionen, die in Firefox11 +, Chrome2 + und IE11 + unterstützt werden, melden Timer, die Sie über console.time() starten/stoppen. time() verwendet einen benutzerdefinierten Timernamen als Argument, und timeEnd() meldet dann 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 Aufruf timeEnd() zurückgibt. Die anderen Browser melden das Ergebnis einfach an die Entwicklerkonsole: Der Rückgabewert von timeEnd() ist undefiniert.

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

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

Das Objekt Date hat jedoch nur eine Auflösung von Millisekunden und wird von Änderungen der Systemuhr des Betriebssystems beeinflusst. In modernen Browsern gibt es eine bessere Option.

Die bessere Option ist die Verwendung von High Resolution Time , auch bekannt als window.performance.now(). now() ist in zweierlei Hinsicht besser als die traditionelle Date.getTime():

1. now() ist ein Double mit einer Auflösung von weniger als einer Millisekunde, das die Anzahl der Millisekunden seit dem Beginn der Seitennavigation angibt. Sie gibt die Anzahl von Mikrosekunden in dem 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 Date.getTime() bei nachfolgenden Aufrufen möglicherweise vorwärts oder sogar rückwärts springen kann. Insbesondere wenn die Systemzeit des Betriebssystems aktualisiert wird (z. B. Atomuhrsynchronisation), wird auch Date.getTime() aktualisiert. now() wird garantiert immer monoton ansteigen, daher wird es nicht von der Systemzeit des Betriebssystems beeinflusst - es wird immer die Wanduhr sein (vorausgesetzt, Ihre Wanduhr ist nicht atomar ...).

now() kann an fast jedem Ort verwendet werden, an dem sich new Date().getTime(), + new Date und Date.now() befinden. Die Ausnahme ist, dass Date und now() sich nicht mischen, da Date auf nix-Epoche (die Anzahl der Millisekunden seit 1970) basiert, während now() die Anzahl ist von Millisekunden seit dem Start der Seitennavigation (also viel kleiner als Date).

Hier ist ein Beispiel für die Verwendung von 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 zur Verfügung.

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

UserTiming hat die Konzepte Marken (Zeitstempel) und Kennzahlen (Dauer). Sie können so viele davon definieren, wie Sie möchten, und sie werden auf der PerformanceTimeline angezeigt.

Um einen Zeitstempel zu speichern, rufen Sie mark(startMarkName) auf. Um die Dauer seit Ihrer ersten Markierung zu ermitteln, rufen Sie einfach measure(measurename, startMarkname) auf. Die Dauer wird dann in der PerformanceTimeline zusammen mit Ihren Noten 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 Polyfill zur Verfügung (die ich geschrieben habe).

Um genaue Werte zu erhalten, sollten Sie Performance interface 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 geeignet, um die genaue Ausführungszeit zu messen. 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 die Echtzeit um 15 bis 60 ms verschieben können.

Überprüfen Sie dieses brillante post zur Messung der Ausführungszeit in JavaScript. Der Autor gibt auch einige Links zur Genauigkeit der JavaScript-Zeit an, die es wert sind, gelesen zu werden. 

Verwenden Sie Firebug, aktivieren Sie sowohl Konsole als auch Javascript. Klicken Sie auf Profil. Neu laden. Klicken Sie erneut auf Profil. Den Bericht anzeigen.

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

Um den Code von vsync weiter zu erweitern, damit timeEnd als Wert in NodeJS zurückgegeben werden kann, verwenden Sie diesen kleinen Code.

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 für weitere Zwecke speichern, z. B. für Gleichungen oder in einer Datenbank, die über Websockets an einen Remote-Client gesendet, auf einer Webseite bereitgestellt wird usw.

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

Es kann dir helfen.

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

Da console.time und performance.now in einigen großen Browsern (d. H. IE10) nicht unterstützt werden, habe ich ein schlankes Dienstprogramm erstellt, das die besten verfügbaren Methoden verwendet. Es gibt jedoch keine Fehlerbehandlung für falsche Verwendungen (Aufruf von End() für einen nicht initialisierten Timer).

Verwenden Sie es und verbessern Sie es nach Belieben. 

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

Danke, Achim Köllner, wird Ihre Antwort etwas 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.log nimmt Zeit in Anspruch und wirkt sich auf Leistungstests aus).

Beachten Sie, dass Sie nach Ablauf der Ausführungszeit von asynchronen Funktionen var timeInMilliseconds = process.hrtime(t0)[1]/1000000; in den Callback einfügen sollten. Zum Beispiel,

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

});

Hier ist ein Dekorateur für Zeitfunktionen

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 async-Funktionen verwenden, können Sie timed async machen und vor f (... args) eine await hinzufügen, und das sollte für diese funktionieren. Es wird komplizierter, wenn ein Dekorateur sowohl Synchronisations- als auch Asynchron-Funktionen ausführen soll. 

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 trimmen

Vor ein paar Monaten habe ich meine eigene Routine zusammengestellt, die mal eine Funktion mit Date.now () erstellt - auch wenn die akzeptierte Methode damals performance.now () --.__ schien. weil das Leistungsobjekt in der stabilen Version von Node.js noch nicht verfügbar (integriert) ist.

Heute recherchierte ich weiter und fand eine andere Methode für das Timing. Da ich auch gefunden habe, wie man dies in Node.js-Code verwendet, dachte ich, ich würde es hier teilen. 

Das Folgende 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 performance-Objekt in einer Node.js-App verwenden möchten, müssen Sie die folgende Anforderung angeben: const { performance } = require('perf_hooks')

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 (), aber einfacher zu verwenden, wenn Sie keine früheren Timer verfolgen 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 kann ich @ grammar suger verwenden und mit babel kompilieren.
Das Problem dieser Methode ist, dass die Funktion innerhalb des Objekts sein muss. 

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

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

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

Console.time verwenden

console.time('someFunction');

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

console.timeEnd('someFunction');

Stoppuhr mit kumulativen Zyklen

Arbeitet mit Server und Client (Knoten oder DOM) und verwendet die Performance-API. Gut, wenn Sie viele kleine Zyklen haben, z. In einer Funktion, die 1000-mal aufgerufen wird und 1000 Datenobjekte verarbeitet, möchten Sie jedoch sehen, wie sich jede Operation in dieser Funktion zur Summe summiert.

Dieser verwendet also einen globalen Zeitgeber (Singleton). Dasselbe wie ein Class-Singleton-Pattern, nur ein bisschen einfacher zu verwenden, aber Sie müssen dies in einem separaten, z. stopwatch.js datei.

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 Modul performance hooks zu verwenden. Obwohl instabil, können Sie mark bestimmte Bereiche Ihres Codes und measure die duration zwischen markierten Bereichen.

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 hier

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

1. using 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: using performance.now ()

ex. 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 + (add operator) 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);

Wenn Sie den Operator unary plus auf eine Date-Instanz anwenden, geschieht Folgendes: Abrufen des Werts der betreffenden Date-Instanz Konvertieren Sie ihn in eine Zahl

HINWEIS: getTime () bietet eine bessere Leistung als unary + operator.