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)
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)
Réponses:
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 Array
contenant le temps réel haute résolution actuel en [secondes, nanosecondes]
process.hrtime()
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.now
et process.uptime
sont 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?
process.hrtime()
pour obtenir un diff. par exemple var startTime = process.hrtime();
et ensuite var diff = process.hrtime(startTime);
.
require("performance.now")
être require("performance-now")
?
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 BigInt
type 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
bigint
version de laprocess.hrtime()
méthode renvoyant le temps réel haute résolution actuel dans un fichierbigint
.
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
process.hrtime.bigint()
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.hrtime
appel 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 setTimeout
ou son setInterval
exé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 hrtime
un 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 accumulator
valeur initiale . On pourrait utiliser 0
comme valeur initiale et cela fonctionnerait également, mais pourquoi faire le supplément * 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
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:
Date.now()
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(''))
Date.now()
S'il vous plaît.