Como obter um microtempo em Node.js?

Como posso obter o registro de data e hora mais preciso no Node.js?

ps Minha versão do Node.js é 0.8.X e a extensão node-microtime não funciona para mim (falha na instalação)

new Date().getTime()? Isso fornece um carimbo de data / hora em milissegundos, que é o mais preciso que o JS fornecerá.

Atualização: conforme afirmado por vaughan, process.hrtime()está disponível no Node.js - sua resolução é de nanossegundos e, portanto, é muito maior, também isso não significa que tenha que ser mais exato.

PS .: Só para ficar mais claro, process.hrtime()retorna uma tupla Arraycontendo o tempo real de alta resolução atual em [segundos, nanossegundos]

No Node.js, o "tempo de alta resolução" é disponibilizado via process.hrtime. Ele retorna uma matriz com o primeiro elemento o tempo em segundos e o segundo elemento os nanossegundos restantes.

Para obter a hora atual em microssegundos, faça o seguinte:

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

(Obrigado a itaifrenkel por apontar um erro na conversão acima.)

Em navegadores modernos, o tempo com precisão de microssegundos está disponível como performance.now. Consulte https://developer.mozilla.org/en-US/docs/Web/API/Performance/now para obter a documentação.

Fiz uma implementação dessa função para Node.js, com base em process.hrtime, que é relativamente difícil de usar se você deseja apenas calcular o diferencial de tempo entre dois pontos em um programa. Veja http://npmjs.org/package/performance-now . De acordo com as especificações, esta função relata o tempo em milissegundos, mas é um float com precisão de submilissegundos.

Na Versão 2.0 deste módulo, os milissegundos relatados são relativos a quando o processo do nó foi iniciado ( Date.now() - (process.uptime() * 1000)). Você precisa adicionar isso ao resultado se quiser um carimbo de data / hora semelhante a Date.now(). Observe também que você deve sempre recalcular Date.now() - (process.uptime() * 1000). Ambos Date.nowe process.uptimesão altamente confiáveis ​​para medições precisas.

Para obter a hora atual em microssegundos, você pode usar algo assim.

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

Veja também: O JavaScript fornece um cronômetro de alta resolução?

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

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

};

O BigInttipo de dados é compatível desde Node.js 10.7.0. ( veja também o anúncio da postagem do blog ). Para essas versões suportadas do Node.js, o process.hrtime([time])método agora é considerado 'legado', substituído pelo process.hrtime.bigint()método.

A bigintversão do process.hrtime()método que retorna o tempo real de alta resolução atual em 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+ - Use process.hrtime.bigint()
• Caso contrário - Use process.hrtime()

Também há https://github.com/wadey/node-microtime :

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

Nanotímero Node.js

Eu escrevi uma biblioteca / objeto wrapper para node.js no topo da process.hrtimechamada de função. Possui funções úteis, como cronometrar tarefas síncronas e assíncronas, especificadas em segundos, milissegundos, micro ou mesmo nano, e segue a sintaxe do cronômetro javascript embutido para ser familiar.

Objetos de cronômetro também são discretos, então você pode ter quantos quiser, cada um com seu próprio processo setTimeoutou em setIntervalexecução.

É chamado de nanotímero . Confira!

Para trabalhar com mais precisão do que Date.now(), mas com milissegundos na precisão flutuante:

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

Obtenha um hrtimeúnico número em uma linha:

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 fornecido um único argumento, usará o primeiro elemento da matriz como o accumulatorvalor inicial . Alguém poderia usar 0como valor inicial e isso também funcionaria, mas por que fazer o extra * 0.

existem pacotes npm que se ligam à função gettimeofday () do sistema, que retorna um carimbo de data / hora de precisão de microssegundo no Linux. Pesquise por npm gettimeofday. Chamar C é mais rápido do queprocess.hrtime()

Uma reescrita para ajudar a compreensão 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

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

Não estou tão orgulhoso com esta solução, mas você pode ter um carimbo de data / hora em microssegundo ou nanossegundo desta forma:

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

Saiba que:

• Esta solução funciona exclusivamente com node.js ,
• Isso é cerca de 3 a 10 vezes mais lento do queDate.now()
• Estranhamente, parece muito preciso, hrTime parece seguir exatamente js timestamp ticks.
• Você pode substituir Date.now()por Number(new Date())para obter o carimbo de data / hora em milissegundos

Editar:

Aqui uma solução para ter microssegundo com vírgula, porém, a versão do número será arredondada nativamente por javascript. Portanto, se você deseja o mesmo formato todas as vezes, deve usar a versão String dele.

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 () não fornece ts atuais.

Isso deve 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)

Melhor?

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