Comment obtenir un microtime dans Node.js?

98

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)

NiLL
la source

Réponses:

102

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]

Niet the Dark Absol
la source
91
Date.now()S'il vous plaît.
jAndy
48
Utilisationprocess.hrtime()
vaughan
2
Je suis d'accord. Cette réponse est complètement fausse. Voir ci-dessous la réponse de @Meryn Stol pour une réponse correcte.
Justin Warkentin
11
process.hrtime () Ces heures sont relatives à une heure arbitraire du passé, et ne sont pas liées à l'heure du jour et ne sont donc pas sujettes à une dérive d'horloge. L'utilisation principale est de mesurer les performances entre les intervalles. Donc ça ne donne pas l'heure actuelle
Alex
9
Toutes les principales réponses sont fausses. process.hrtime()ne renvoie pas l'heure actuelle.
175

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?

Myrne Stol
la source
27
Il est à noter que pour faire un benchmark, vous pouvez passer le résultat d'un appel précédent à process.hrtime()pour obtenir un diff. par exemple var startTime = process.hrtime();et ensuite var diff = process.hrtime(startTime);.
Justin Warkentin
5
Veuillez vérifier les unités de temps lors de la conversion des secondes en microsecondes. console.log (hrTime [0] * 1000000 + hrTime [1] / 1000)
itaifrenkel
Merci d'avoir signalé cette erreur, itaifrenkel! J'ai corrigé le code de conversion.
Myrne Stol
2
Ne devrait pas l' require("performance.now")être require("performance-now")?
UpTheCreek
5
process.hrtime()ne renvoie pas l'heure actuelle.
21
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');
  }

};
Abdennour TOUMI
la source
14
process.hrtime()ne renvoie pas l'heure actuelle.
quel Os vous avez?
Abdennour TOUMI
11

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()
d4nyll
la source
8

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

> var microtime = require('microtime')
> microtime.now()
1297448895297028
Mikemaccana
la source
OP a déclaré avoir essayé ce package et ne pouvait pas le faire installer.
Cameron Tacklind le
@CameronTacklind Ah ils l'ont fait - ils l'ont appelé une «extension»; ce qui m'a fait manquer ça. Étant donné que beaucoup de gens viennent à cet article via la question - qui est de savoir comment faire un microtime sur un nœud - la réponse est toujours utile.
mikemaccana
5

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!

krb686
la source
2

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;
}
Ross
la source
2
process.hrtime () ne renvoie pas l'heure actuelle
Marc J. Schmidt
Vous avez raison. D'après la documentation: "Ces heures sont relatives à une heure arbitraire dans le passé, et ne sont pas liées à l'heure du jour et ne sont donc pas sujettes à une dérive d'horloge. L'utilisation principale est de mesurer les performances entre les intervalles" nodejs.org/api/process .html # process_process_hrtime_time
Ross
1

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.

Cameron Tacklind
la source
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()

Andras
la source
0

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

Manohar Reddy Poreddy
la source
0

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
pirs
la source
0

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)
Saravana Kumar Chinnaraj
la source
-8

mieux?

Number(process.hrtime().join(''))
infinito84
la source
3
Cela ne fonctionne pas du tout. NE PAS UTILISER. Étant donné que ces valeurs sont des entiers, le deuxième élément du tableau n'aura jamais une largeur fixe. Les zéros non significatifs ne sont pas là pour que cela soit joint en tant que chaîne.
user.friendly
Number (process.hrtime (). Map ((n, i) => i? ('000000000' + n) .slice (-9): n) .join (''))
Mike