Wie bekomme ich eine Microtime in Node.js?

Wie kann ich den genauesten Zeitstempel in Node.js erhalten?

ps Meine Version von Node.js ist 0.8.X und die Node-Microtime-Erweiterung funktioniert bei mir nicht (Absturz bei der Installation)

new Date().getTime()? Dies gibt Ihnen einen Zeitstempel in Millisekunden, der der genaueste ist, den JS Ihnen geben wird.

Update: Wie von Vaughan angegeben, process.hrtime() ist es in Node.js verfügbar - seine Auflösung beträgt Nanosekunden und ist daher viel höher. Dies bedeutet auch nicht, dass es genauer sein muss.

PS.: Um es klarer zu machen, erhalten process.hrtime()Sie ein Tupel Arraymit der aktuellen hochauflösenden Echtzeit in [Sekunden, Nanosekunden].

In Node.js wird "Zeit mit hoher Auflösung" über zur Verfügung gestellt process.hrtime. Es gibt ein Array mit dem ersten Element in Sekunden und dem zweiten Element in den verbleibenden Nanosekunden zurück.

Gehen Sie wie folgt vor, um die aktuelle Zeit in Mikrosekunden abzurufen:

var hrTime = process.hrtime()
console.log(hrTime[0] * 1000000 + hrTime[1] / 1000)

(Vielen Dank an itaifrenkel für den Hinweis auf einen Fehler bei der obigen Konvertierung.)

In modernen Browsern steht Zeit mit Mikrosekundengenauigkeit als zur Verfügung performance.now. Dokumentation finden Sie unter https://developer.mozilla.org/en-US/docs/Web/API/Performance/now .

Ich habe eine Implementierung dieser Funktion für Node.js basierend auf erstellt process.hrtime, die relativ schwierig zu verwenden ist, wenn Sie nur die Zeitdifferenz zwischen zwei Punkten in einem Programm berechnen möchten. Siehe http://npmjs.org/package/performance-now . Gemäß der Spezifikation gibt diese Funktion die Zeit in Millisekunden an, ist jedoch ein Float mit einer Genauigkeit von weniger als einer Millisekunde.

In Version 2.0 dieses Moduls beziehen sich die angegebenen Millisekunden auf den Zeitpunkt, zu dem der Knotenprozess gestartet wurde ( Date.now() - (process.uptime() * 1000)). Sie müssen dies zum Ergebnis hinzufügen, wenn Sie einen ähnlichen Zeitstempel möchten Date.now(). Beachten Sie auch, dass Sie eine Neuberechnung durchführen sollten Date.now() - (process.uptime() * 1000). Beide Date.nowund process.uptimesind für präzise Messungen sehr unzuverlässig.

Um die aktuelle Zeit in Mikrosekunden abzurufen, können Sie so etwas verwenden.

var loadTimeInMS = Date.now()
var performanceNow = require("performance-now")
console.log((loadTimeInMS + performanceNow()) * 1000)

Siehe auch: Bietet JavaScript einen hochauflösenden Timer?

now('milli'); //  120335360.999686
now('micro') ; // 120335360966.583
now('nano') ; //  120335360904333

Bekannt nowist das:

const now = (unit) => {

  const hrTime = process.hrtime();

  switch (unit) {

    case 'milli':
      return hrTime[0] * 1000 + hrTime[1] / 1000000;

    case 'micro':
      return hrTime[0] * 1000000 + hrTime[1] / 1000;

    case 'nano':
      return hrTime[0] * 1000000000 + hrTime[1];

    default:
      return now('nano');
  }

};

Der BigIntDatentyp wird seit Node.js 10.7.0 unterstützt. ( Siehe auch die Ankündigung des Blogposts ). Für diese unterstützten Versionen von Node.js wird die process.hrtime([time])Methode jetzt als "Legacy" betrachtet und durch die process.hrtime.bigint()Methode ersetzt.

Die bigintVersion der process.hrtime()Methode, die die aktuelle hochauflösende Echtzeit in a zurückgibt bigint.

const start = process.hrtime.bigint();
// 191051479007711n

setTimeout(() => {
  const end = process.hrtime.bigint();
  // 191052633396993n

  console.log(`Benchmark took ${end - start} nanoseconds`);
  // Benchmark took 1154389282 nanoseconds
}, 1000);

tl; dr

• Node.js 10.7.0+ - Verwenden process.hrtime.bigint()
• Andernfalls - Verwenden process.hrtime()

Es gibt auch https://github.com/wadey/node-microtime :

> var microtime = require('microtime')
> microtime.now()
1297448895297028

Node.js Nanotimer

Ich habe eine Wrapper-Bibliothek / ein Wrapper-Objekt für node.js über den process.hrtimeFunktionsaufruf geschrieben. Es verfügt über nützliche Funktionen wie das Timing von synchronen und asynchronen Aufgaben, die in Sekunden, Millisekunden, Mikro oder sogar Nano angegeben sind, und folgt der Syntax des integrierten Javascript-Timers, um vertraut zu sein.

Timer-Objekte sind ebenfalls diskret, sodass Sie so viele Objekte haben können, wie Sie möchten, jedes mit einem eigenen setTimeoutoder einem setIntervallaufenden Prozess.

Es heißt Nanotimer . Hör zu!

So arbeiten Sie präziser als Date.now(), aber mit Millisekunden in Float-Präzision:

function getTimeMSFloat() {
    var hrtime = process.hrtime();
    return ( hrtime[0] * 1000000 + hrtime[1] / 1000 ) / 1000;
}

Erhalten Sie hrtimeals einzelne Zahl in einer Zeile:

const begin = process.hrtime();
// ... Do the thing you want to measure
const nanoSeconds = process.hrtime(begin).reduce((sec, nano) => sec * 1e9 + nano)

Array.reduceWenn ein einzelnes Argument angegeben wird, wird das erste Element des Arrays als Anfangswert accumulatorverwendet. Man könnte 0als Anfangswert verwenden und dies würde auch funktionieren, aber warum das Extra tun * 0.

Es gibt npm-Pakete, die an die Systemfunktion gettimeofday () gebunden sind, die unter Linux einen Zeitstempel mit einer Genauigkeit von Mikrosekunden zurückgibt. Suche nach npm gettimeofday. Das Aufrufen von C ist schneller alsprocess.hrtime()

Ein Umschreiben zum schnellen Verständnis:

const hrtime = process.hrtime();     // [0] is seconds, [1] is nanoseconds

let nanoSeconds = (hrtime[0] * 1e9) + hrtime[1];    // 1 second is 1e9 nano seconds
console.log('nanoSeconds:  ' + nanoSeconds);
//nanoSeconds:  97760957504895

let microSeconds = parseInt(((hrtime[0] * 1e6) + (hrtime[1]) * 1e-3));
console.log('microSeconds: ' + microSeconds);
//microSeconds: 97760957504

let milliSeconds = parseInt(((hrtime[0] * 1e3) + (hrtime[1]) * 1e-6));
console.log('milliSeconds: ' + milliSeconds);
//milliSeconds: 97760957

Quelle: https://nodejs.org/api/process.html#process_process_hrtime_time

Ich bin nicht so stolz auf diese Lösung, aber Sie können den Zeitstempel in Mikrosekunden oder Nanosekunden folgendermaßen anzeigen :

const microsecond = () => Number(Date.now() + String(process.hrtime()[1]).slice(3,6))
const nanosecond = () => Number(Date.now() + String(process.hrtime()[1]).slice(3))

// usage
microsecond() // return 1586878008997591
nanosecond()  // return 1586878009000645600

// Benchmark with 100 000 iterations
// Date.now: 7.758ms
// microsecond: 33.382ms
// nanosecond: 31.252ms

Wisse das:

• Diese Lösung funktioniert ausschließlich mit node.js ,
• Dies ist etwa 3 bis 10 mal langsamer alsDate.now()
• Seltsamerweise scheint es sehr genau zu sein, hrTime scheint genau js Zeitstempel-Ticks zu folgen.
• Sie können ersetzen Date.now()durch Number(new Date())in Millisekunden erhalten Zeitstempel

Bearbeiten:

Hier eine Lösung, um Mikrosekunden mit Komma zu haben, jedoch wird die Zahlenversion nativ durch Javascript gerundet. Wenn Sie also jedes Mal dasselbe Format möchten, sollten Sie die String-Version verwenden.

const microsecondWithCommaString = () => (Date.now() + '.' + String(process.hrtime()[1]).slice(3,7))
const microsecondWithComma = () => Number(Date.now() + '.' + String(process.hrtime()[1]).slice(3,7))

microsecondWithCommaString() // return "1586883629984.8997"
microsecondWithComma() // return 1586883629985.966

process.hrtime () gibt keinen aktuellen ts an.

Das sollte funktionieren.

 const loadNs       = process.hrtime(),
        loadMs       = new Date().getTime(),
        diffNs       = process.hrtime(loadNs),
        microSeconds = (loadMs * 1e6) + (diffNs[0] * 1e9) + diffNs[1]

  console.log(microSeconds / 1e3)

besser?

Number(process.hrtime().join(''))