Wie kann ich die Ausführungszeit von JavaScript-Code mit Rückrufen messen?

Question

Ich habe ein Stück JavaScript-Code, den ich mit der node.js Dolmetscher.

for(var i = 1; i < LIMIT; i++) {
  var user = {
    id: i,
    name: "MongoUser [" + i + "]"
  };
  db.users.save(user, function(err, saved) {
    if(err || !saved) {
      console.log("Error");
    } else {
      console.log("Saved");
    }
  });
}

Wie kann ich die Zeit messen, die diese Einfügeoperationen in die Datenbank benötigen? Ich könnte die Differenz der Datumswerte nach und vor diesem Codestück berechnen, aber das wäre wegen der asynchronen Natur des Codes nicht korrekt.

Answer 1

Verwenden Sie die Node.js console.time() y console.timeEnd() :

var i;
console.time("dbsave");

for(i = 1; i < LIMIT; i++){
    db.users.save({id : i, name : "MongoUser [" + i + "]"}, end);
}

end = function(err, saved) {
    console.log(( err || !saved )?"Error":"Saved");
    if(--i === 1){
      console.timeEnd("dbsave");
    }
};

Answer 2

Es gibt eine Methode, die für diesen Zweck entwickelt wurde. Ausprobieren process.hrtime(); .

Ich habe dies also an den Anfang meiner App gestellt.

var start = process.hrtime();

var elapsed_time = function(note){
    var precision = 3; // 3 decimal places
    var elapsed = process.hrtime(start)[1] / 1000000; // divide by a million to get nano to milli
    console.log(process.hrtime(start)[0] + " s, " + elapsed.toFixed(precision) + " ms - " + note); // print message + time
    start = process.hrtime(); // reset the timer
}

Dann benutze ich es, um zu sehen, wie lange Funktionen dauern. Hier ist ein einfaches Beispiel, das den Inhalt einer Textdatei namens "output.txt" ausgibt:

var debug = true;
http.createServer(function(request, response) {

    if(debug) console.log("----------------------------------");
    if(debug) elapsed_time("recieved request");

    var send_html = function(err, contents) {
        if(debug) elapsed_time("start send_html()");
        response.writeHead(200, {'Content-Type': 'text/html' } );
        response.end(contents);
        if(debug) elapsed_time("end send_html()");
    }

    if(debug) elapsed_time("start readFile()");
    fs.readFile('output.txt', send_html);
    if(debug) elapsed_time("end readFile()");

}).listen(8080);

Hier ist ein schneller Test, den Sie in einem Terminal (BASH-Shell) durchführen können:

for i in {1..100}; do echo $i; curl http://localhost:8080/; done

Answer 3

Aufrufen von console.time('label') zeichnet die aktuelle Zeit in Millisekunden auf und ruft dann später console.timeEnd('label') wird die Dauer ab diesem Punkt angezeigt.

Die Zeit in Millisekunden wird automatisch zusammen mit dem Etikett gedruckt, so dass Sie keinen separaten Aufruf von console.log machen müssen, um ein Etikett zu drucken:

console.time('test');
//some code
console.timeEnd('test'); //Prints something like that-> test: 11374.004ms

Weitere Informationen finden Sie unter Mozillas Dokumente für Entwickler über console.time .

Answer 4

Ich bin überrascht, dass noch niemand die neuen eingebauten Bibliotheken erwähnt hat:

Verfügbar in Node >= 8.5, und sollte in modernen Browsern vorhanden sein

https://developer.mozilla.org/en-US/docs/Web/API/Performance

https://nodejs.org/docs/latest-v8.x/api/perf_hooks.html#

Node 8.5 ~ 9.x (Firefox, Chrome)

// const { performance } = require('perf_hooks'); // enable for node
const delay = time => new Promise(res=>setTimeout(res,time))
async function doSomeLongRunningProcess(){
  await delay(1000);
}
performance.mark('A');
(async ()=>{
  await doSomeLongRunningProcess();
  performance.mark('B');
  performance.measure('A to B', 'A', 'B');
  const measure = performance.getEntriesByName('A to B')[0];
  // firefox appears to only show second precision.
  console.log(measure.duration);
  // apparently you should clean up...
  performance.clearMarks();
  performance.clearMeasures();         
  // Prints the number of milliseconds between Mark 'A' and Mark 'B'
})();

https://repl.it/@CodyGeisler/NodeJsPerformanceHooks

Node 12.x

https://nodejs.org/docs/latest-v12.x/api/perf_hooks.html

const { PerformanceObserver, performance } = require('perf_hooks');
const delay = time => new Promise(res => setTimeout(res, time))
async function doSomeLongRunningProcess() {
    await delay(1000);
}
const obs = new PerformanceObserver((items) => {
    console.log('PerformanceObserver A to B',items.getEntries()[0].duration);
      // apparently you should clean up...
      performance.clearMarks();
      // performance.clearMeasures(); // Not a function in Node.js 12
});
obs.observe({ entryTypes: ['measure'] });

performance.mark('A');

(async function main(){
    try{
        await performance.timerify(doSomeLongRunningProcess)();
        performance.mark('B');
        performance.measure('A to B', 'A', 'B');
    }catch(e){
        console.log('main() error',e);
    }
})();

Answer 5

Für alle, die den Wert der verstrichenen Zeit anstelle der Konsolenausgabe erhalten möchten:

verwenden. process.hrtime() wie @D.Deriso vorschlug, ist unten mein einfacherer Ansatz:

function functionToBeMeasured() {
    var startTime = process.hrtime();
    // do some task...
    // ......
    var elapsedSeconds = parseHrtimeToSeconds(process.hrtime(startTime));
    console.log('It takes ' + elapsedSeconds + 'seconds');
}

function parseHrtimeToSeconds(hrtime) {
    var seconds = (hrtime[0] + (hrtime[1] / 1e9)).toFixed(3);
    return seconds;
}