Come ottenere un microtime in Node.js?

Come posso ottenere il timestamp più preciso in Node.js?

ps La mia versione di Node.js è 0.8.X e l' estensione node-microtime non funziona per me (crash durante l'installazione)

new Date().getTime()? Questo ti dà un timestamp in millisecondi, che è il più preciso che JS ti darà.

Aggiornamento: come affermato da vaughan, process.hrtime() è disponibile all'interno di Node.js - la sua risoluzione è in nanosecondi e quindi è molto più alta, anche questo non significa che debba essere più preciso.

PS .: Per essere più chiari, process.hrtime()ti restituisce una tuplaArray contenente l'attuale tempo reale ad alta risoluzione in [secondi, nanosecondi]

In Node.js, "tempo ad alta risoluzione" è reso disponibile tramite process.hrtime. Restituisce un array con il primo elemento il tempo in secondi e il secondo elemento i nanosecondi rimanenti.

Per ottenere l'ora corrente in microsecondi, procedi come segue:

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

(Grazie a itaifrenkel per aver segnalato un errore nella conversione sopra.)

Nei browser moderni, il tempo con precisione al microsecondo è disponibile come performance.now. Vedi https://developer.mozilla.org/en-US/docs/Web/API/Performance/now per la documentazione.

Ho realizzato un'implementazione di questa funzione per Node.js, basata su process.hrtime, che è relativamente difficile da usare se si desidera esclusivamente calcolare il differenziale di tempo tra due punti in un programma. Vedi http://npmjs.org/package/performance-now . Secondo le specifiche, questa funzione riporta il tempo in millisecondi, ma è un float con una precisione inferiore al millisecondo.

Nella versione 2.0 di questo modulo, i millisecondi riportati sono relativi a quando è stato avviato il processo del nodo ( Date.now() - (process.uptime() * 1000)). È necessario aggiungerlo al risultato se si desidera un timestamp simile a Date.now(). Nota anche che dovresti ricalcolare le bevande Date.now() - (process.uptime() * 1000). Entrambi Date.nowe process.uptimesono altamente inaffidabili per misurazioni precise.

Per ottenere l'ora corrente in microsecondi, puoi usare qualcosa di simile.

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

Vedi anche: JavaScript fornisce un timer ad alta risoluzione?

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

Noto che nowè:

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

};

Il BigInttipo di dati è supportato da Node.js 10.7.0. ( vedi anche l' annuncio del post sul blog ). Per queste versioni supportate di Node.js, il process.hrtime([time])metodo è ora considerato "legacy", sostituito dal process.hrtime.bigint()metodo.

La bigintversione del process.hrtime()metodo che restituisce l'attuale tempo reale ad alta risoluzione in un file 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+ - Usa process.hrtime.bigint()
• Altrimenti - Usa process.hrtime()

C'è anche https://github.com/wadey/node-microtime :

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

Node.js nanotimer

Ho scritto una libreria / oggetto wrapper per node.js sopra la process.hrtimechiamata alla funzione. Ha funzioni utili, come la temporizzazione delle attività sincrone e asincrone, specificate in secondi, millisecondi, micro o anche nano, e segue la sintassi del timer javascript integrato in modo da essere familiare.

Anche gli oggetti timer sono discreti, quindi puoi averne quanti ne desideri, ognuno con il proprio setTimeouto setIntervalprocesso in esecuzione.

Si chiama nanotimero . Controlla!

Per lavorare con maggiore precisione rispetto Date.now(), ma con millisecondi in virgola mobile:

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

Ottieni hrtimeun numero singolo in una riga:

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

Array.reduce, quando viene fornito un singolo argomento, utilizzerà il primo elemento dell'array come accumulatorvalore iniziale . Si potrebbe usare 0come valore iniziale e anche questo funzionerebbe, ma perché fare l'extra * 0.

ci sono pacchetti npm che si collegano alla funzione di sistema gettimeofday (), che restituisce un timestamp di precisione al microsecondo su Linux. Cerca npm gettimeofday. Chiamare C è più veloce diprocess.hrtime()

Una riscrittura per aiutare una rapida comprensione:

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

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

Non sono così orgoglioso di questa soluzione ma puoi avere il timestamp in microsecondi o nanosecondi in questo modo:

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

Sapere che:

• Questa soluzione funziona esclusivamente con node.js ,
• Questo è da 3 a 10 volte più lento diDate.now()
• Stranamente, sembra molto preciso, hrTime sembra seguire esattamente js timestamp tick.
• Puoi sostituire Date.now()con Number(new Date())per ottenere il timestamp in millisecondi

Modificare:

Ecco una soluzione per avere microsecondi con virgola, tuttavia, il numero di versione verrà arrotondato nativamente da javascript. Quindi, se vuoi lo stesso formato ogni volta, dovresti usare la versione String.

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 () non fornisce ts corrente.

Questo dovrebbe funzionare.

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

  console.log(microSeconds / 1e3)

meglio?

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