¿Cómo obtener un microtiempo en Node.js?

¿Cómo puedo obtener la marca de tiempo más precisa en Node.js?

ps Mi versión de Node.js es 0.8.X y la extensión node-microtime no me funciona (falla en la instalación)

new Date().getTime()? Esto le da una marca de tiempo en milisegundos, que es la más precisa que le dará JS.

Actualización: como dijo vaughan, process.hrtime()está disponible dentro de Node.js: su resolución es de nanosegundos y, por lo tanto, es mucho más alta, y esto no significa que tenga que ser más exacta.

PD: Para ser más claro, process.hrtime()te devuelve una tupla que Arraycontiene el tiempo real de alta resolución actual en [segundos, nanosegundos]

En Node.js, el "tiempo de alta resolución" está disponible a través de process.hrtime. Devuelve una matriz con el primer elemento el tiempo en segundos y el segundo elemento los nanosegundos restantes.

Para obtener la hora actual en microsegundos, haga lo siguiente:

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

(Gracias a itaifrenkel por señalar un error en la conversión anterior).

En los navegadores modernos, el tiempo con precisión de microsegundos está disponible como performance.now. Consulte https://developer.mozilla.org/en-US/docs/Web/API/Performance/now para obtener documentación.

Hice una implementación de esta función para Node.js, basada en process.hrtime, que es relativamente difícil de usar si solo desea calcular la diferencia de tiempo entre dos puntos en un programa. Consulte http://npmjs.org/package/performance-now . Según la especificación, esta función informa el tiempo en milisegundos, pero es un flotador con una precisión de menos de milisegundos.

En la versión 2.0 de este módulo, los milisegundos informados son relativos a cuando se inició el proceso del nodo ( Date.now() - (process.uptime() * 1000)). Debe agregar eso al resultado si desea una marca de tiempo similar a Date.now(). También tenga en cuenta que debería volver a calcular Date.now() - (process.uptime() * 1000). Ambos Date.nowy process.uptimeson muy poco fiables para realizar mediciones precisas.

Para obtener la hora actual en microsegundos, puede usar algo como esto.

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

Consulte también: ¿JavaScript proporciona un temporizador de alta resolución?

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

Conocido que nowes:

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

};

los BigInt tipo de datos es compatible desde Node.js 10.7.0. ( ver también el anuncio de la publicación del blog ). Para estas versiones compatibles de Node.js, el process.hrtime([time])método ahora se considera 'heredado', reemplazado por el process.hrtime.bigint()método.

los bigint versión del process.hrtime()método que devuelve el tiempo real de alta resolución actual en a 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+: uso process.hrtime.bigint()
• De lo contrario, utilice process.hrtime()

También hay https://github.com/wadey/node-microtime :

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

Nanotimer de Node.js

Escribí una biblioteca / objeto contenedor para node.js en la parte superior del process.hrtime llamada a función. Tiene funciones útiles, como sincronizar tareas sincrónicas y asincrónicas, especificadas en segundos, milisegundos, micro o incluso nano, y sigue la sintaxis del temporizador javascript integrado para resultar familiar.

Los objetos de temporizador también son discretos, por lo que puede tener tantos como desee, cada uno con su propio proceso setTimeouto en setIntervalejecución.

Se llama nanotimer . ¡Echale un vistazo!

Para trabajar con más precisión que Date.now(), pero con milisegundos en precisión flotante:

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

Obtenga un hrtimesolo número en una línea:

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

Array.reduce, cuando se le da un solo argumento, usará el primer elemento de la matriz como accumulatorvalor inicial . Se podría usar 0como valor inicial y esto también funcionaría, pero ¿por qué hacer el extra * 0?

hay paquetes npm que se vinculan a la función gettimeofday () del sistema, que devuelve una marca de tiempo de precisión de microsegundos en Linux. Busque npm gettimeofday. Llamar a C es más rápido queprocess.hrtime()

Una reescritura para ayudar a una comprensión rápida:

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

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

No estoy tan orgulloso de esta solución, pero puede tener una marca de tiempo en microsegundos o nanosegundos de esta manera:

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

Saber que:

• Esta solución funciona exclusivamente con node.js ,
• Esto es aproximadamente de 3 a 10 veces más lento queDate.now()
• Extrañamente, parece muy preciso, hrTime parece seguir exactamente los ticks de la marca de tiempo js.
• Puede reemplazar Date.now()por Number(new Date())para obtener la marca de tiempo en milisegundos

Editar:

Aquí una solución para tener microsegundos con coma, sin embargo, la versión del número será redondeada de forma nativa por javascript. Entonces, si desea el mismo formato cada vez, debe usar la versión 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 () no da ts actuales.

Esto debería funcionar.

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

  console.log(microSeconds / 1e3)

¿mejor?

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