Comment obtenir un microtime dans Node.js?

Comment puis-je obtenir l'horodatage le plus précis dans Node.js?

ps Ma version de Node.js est 0.8.X et l' extension node-microtime ne fonctionne pas pour moi (crash lors de l'installation)

new Date().getTime()? Cela vous donne un horodatage en millisecondes, qui est le plus précis que JS vous donnera.

Mise à jour: Comme indiqué par vaughan, process.hrtime()est disponible dans Node.js - sa résolution est en nanosecondes et donc beaucoup plus élevée, cela ne signifie pas non plus qu'elle doit être plus exacte.

PS: Pour être plus clair, process.hrtime()vous renvoie un tuple Arraycontenant le temps réel haute résolution actuel en [secondes, nanosecondes]

Dans Node.js, le "temps haute résolution" est rendu disponible via process.hrtime. Il renvoie un tableau avec le premier élément le temps en secondes et le second élément les nanosecondes restantes.

Pour obtenir l'heure actuelle en microsecondes, procédez comme suit:

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

(Merci à itaifrenkel d' avoir signalé une erreur dans la conversion ci-dessus.)

Dans les navigateurs modernes, l'heure à la microseconde est disponible sous forme de performance.now. Voir https://developer.mozilla.org/en-US/docs/Web/API/Performance/now pour la documentation.

J'ai fait une implémentation de cette fonction pour Node.js, basée sur process.hrtime, qui est relativement difficile à utiliser si vous voulez uniquement calculer la différence de temps entre deux points dans un programme. Voir http://npmjs.org/package/performance-now . Selon la spécification, cette fonction rapporte le temps en millisecondes, mais c'est un float avec une précision inférieure à la milliseconde.

Dans la version 2.0 de ce module, les millisecondes signalées sont relatives au moment où le processus de nœud a été démarré ( Date.now() - (process.uptime() * 1000)). Vous devez l'ajouter au résultat si vous souhaitez un horodatage similaire à Date.now(). Notez également que vous devez recalculer Date.now() - (process.uptime() * 1000). Les deux Date.nowet process.uptimesont très peu fiables pour des mesures précises.

Pour obtenir l'heure actuelle en microsecondes, vous pouvez utiliser quelque chose comme ceci.

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

Voir aussi: JavaScript fournit-il un minuteur haute résolution?

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

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

};

Le BigInttype de données est pris en charge depuis Node.js 10.7.0. ( voir aussi l' annonce du billet de blog ). Pour ces versions prises en charge de Node.js, la process.hrtime([time])méthode est désormais considérée comme «héritée», remplacée par la process.hrtime.bigint()méthode.

La bigintversion de la process.hrtime()méthode renvoyant le temps réel haute résolution actuel dans un fichier 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+ - Utilisation process.hrtime.bigint()
• Sinon - Utiliser process.hrtime()

Il y a aussi https://github.com/wadey/node-microtime :

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

Node.js nanotimer

J'ai écrit une bibliothèque / objet wrapper pour node.js en plus de l' process.hrtimeappel de fonction. Il a des fonctions utiles, comme le chronométrage des tâches synchrones et asynchrones, spécifiées en secondes, millisecondes, micro ou même nano, et suit la syntaxe du minuteur JavaScript intégré pour être familier.

Les objets Timer sont également discrets, vous pouvez donc en avoir autant que vous le souhaitez, chacun avec son propre processus setTimeoutou son setIntervalexécution.

Cela s'appelle nanotimer . Vérifiez-le!

Pour travailler avec plus de précision que Date.now(), mais avec des millisecondes en précision flottante:

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

Obtenez hrtimeun numéro unique sur une ligne:

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

Array.reduce, lorsqu'il est donné un seul argument, utilisera le premier élément du tableau comme accumulatorvaleur initiale . On pourrait utiliser 0comme valeur initiale et cela fonctionnerait également, mais pourquoi faire le supplément * 0.

il existe des packages npm qui se lient à la fonction système gettimeofday (), qui renvoie un horodatage de précision à la microseconde sous Linux. Recherchez npm gettimeofday. Appeler C est plus rapide queprocess.hrtime()

Une réécriture pour aider à une compréhension rapide:

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

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

Je ne suis pas si fier de cette solution mais vous pouvez avoir un horodatage en microseconde ou nanoseconde de cette manière:

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

Sachez que:

• Cette solution fonctionne exclusivement avec node.js ,
• C'est environ 3 à 10 fois plus lent queDate.now()
• Bizarrement, cela semble très précis, hrTime semble suivre exactement les graduations d'horodatage js.
• Vous pouvez remplacer Date.now()par Number(new Date())pour obtenir l'horodatage en millisecondes

Éditer:

Voici une solution pour avoir la microseconde avec virgule, cependant, la version numérique sera arrondie nativement par javascript. Donc, si vous voulez le même format à chaque fois, vous devez utiliser la version String de celui-ci.

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 () ne donne pas le ts actuel.

Cela devrait fonctionner.

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

  console.log(microSeconds / 1e3)

mieux?

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