Question Comment mesurer le temps pris par une fonction à exécuter


Je dois obtenir le temps d'exécution en millisecondes.

J'ai d'abord posé cette question en 2008. La réponse acceptée   alors devait utiliser new Date (). getTime () Cependant, nous pouvons tous être d'accord maintenant   que l'utilisation de la norme performance.now () API est plus   approprié. Je change donc la réponse acceptée à celle-ci.


786
2017-11-24 11:09


origine


Réponses:


Vous pouvez utiliser console.time: (non standard)

console.time('someFunction');

someFunction(); // run whatever needs to be timed in between the statements

console.timeEnd('someFunction');

Remarque:


1148
2017-12-29 15:05



utilisation new Date (). getTime ()

La méthode getTime () renvoie le nombre de millisecondes écoulées depuis minuit le 1er janvier 1970.

ex.

var start = new Date().getTime();

for (i = 0; i < 50000; ++i) {
// do something
}

var end = new Date().getTime();
var time = end - start;
alert('Execution time: ' + time);

572
2017-11-24 11:15



N'utilisez pas Date (). Lire ci-dessous.

Utilisation performance.now():

<script>
var a = performance.now();
alert('do something...');
var b = performance.now();
alert('It took ' + (b - a) + ' ms.');
</script>

Cela fonctionne sur:

  • IE 10 ++

  • FireFox 15 ++

  • Chrome 24 ++

  • Safari 8 ++

  • Opéra 15 ++

  • Android 4.4 ++

  • etc

console.time peut être viable pour toimais c'est non standard §:

Cette fonctionnalité est non standard et n'est pas sur une piste de normalisation. Ne l'utilisez pas sur des sites de production tournés vers le Web: cela ne fonctionnera pas pour tous les utilisateurs. Là peut également être de grandes incompatibilités entre les implémentations et le comportement peut changer dans le futur.

Outre le support du navigateur, performance.now semble avoir le potentiel pour fournir des horaires plus précis car il semble être la version bare-bones de console.time.


<rant> Aussi, N'utilisez JAMAIS Date pour n'importe quoi car il est affecté par les changements de "temps système". Ce qui signifie que nous volonté obtenir des résultats non valides - comme "timing négatif" - lorsque l'utilisateur n'a pas une heure système précise:

En Octobre 2014, mon horloge système est tombée en désordre et devine quoi.... J'ai ouvert Gmail et j'ai vu tout des courriels de ma journée "envoyés Il y a 0 minutes"Et je pensais que Gmail est censé être construit par des ingénieurs de classe mondiale de Google .......

(Réglez l'horloge de votre système sur un an et allez sur Gmail pour que nous puissions tous rire un peu. Hall de la honte pour JS Date.)

Google Spreadsheet now() fonction souffre également de ce problème.

La seule fois où vous utiliserez Date est quand vous voulez montrer à l'utilisateur le sien heure de l'horloge système. Pas quand vous voulez obtenir la temps ou pour mesurer quoi que ce soit.


376
2018-03-26 15:49



Si vous avez besoin d'obtenir le temps d'exécution de la fonction sur votre machine de développement locale, vous pouvez utiliser les outils de profilage de votre navigateur ou des commandes de console telles que console.time() et console.timeEnd().

Tous les navigateurs modernes ont des profileurs JavaScript intégrés. Ces profileurs doivent donner la mesure la plus précise possible car vous n'avez pas besoin de modifier votre code existant, ce qui pourrait affecter le temps d'exécution de la fonction.

Pour profiler votre JavaScript:

  • Dans Chrome, presse F12 et sélectionnez le Profils onglet, puis Recueillir le profil de CPU JavaScript.
  • Dans Firefox, installez / ouvrez Firebug, et cliquez sur Profil bouton.
  • Dans IE 9+, presse F12, cliquer sur Scénario ou Profiler (en fonction de votre version de IE).

Alternativement, sur votre machine de développement, vous pouvez ajouter de l'instrumentation à votre code avec console.time() et console.timeEnd(). Ces fonctions, prises en charge dans Firefox11 +, Chrome2 + et IE11 +, signalent les minuteries que vous démarrez / arrêtez via console.time(). time() prend un nom de temporisateur défini par l'utilisateur comme argument, et timeEnd() puis signale le temps d'exécution depuis le début de la minuterie:

function a() {
  console.time("mytimer");
  ... do stuff ...
  var dur = console.timeEnd("myTimer"); // NOTE: dur only works in FF
}

Notez que seul Firefox renvoie le temps écoulé dans le timeEnd() appel. Les autres navigateurs rapportent simplement le résultat à la console du développeur: la valeur de retour de timeEnd() est indéfini.

Si vous voulez obtenir le temps d'exécution de la fonction dans la nature, vous devrez instrumenter votre code. Vous avez plusieurs options. Vous pouvez simplement enregistrer les heures de début et de fin en interrogeant new Date().getTime():

function a() {
  var start = new Date().getTime();
  ... do stuff ...
  var end = new Date().getTime();
  var dur = end - start;
}

Cependant, le Date L'objet n'a qu'une résolution d'une milliseconde et sera affecté par les changements d'horloge système de tout système d'exploitation. Dans les navigateurs modernes, il y a une meilleure option.

La meilleure option est d'utiliser le Temps de haute résolution, alias window.performance.now(). now() est meilleur que le traditionnel Date.getTime() de deux manières importantes:

  1. now() est un double avec une résolution de submillisecond qui représente le nombre de millisecondes depuis le début de la navigation de la page. Il renvoie le nombre de microsecondes dans le fractionnaire (par exemple une valeur de 1000.123 est 1 seconde et 123 microsecondes).

  2. now() augmente de façon monotone. Ceci est important car Date.getTime() pouvez peut-être sauter en avant ou même en arrière sur les appels suivants. Notamment, si l'heure système de l'OS est mise à jour (par exemple, la synchronisation de l'horloge atomique), Date.getTime() est également mis à jour. now() est garanti pour toujours augmenter de façon monotone, donc il n'est pas affecté par l'heure système de l'OS - ce sera toujours l'heure de l'horloge murale (en supposant que votre horloge murale n'est pas atomique ...).

now() peut être utilisé dans presque tous les endroits new Date().getTime(), + new Date et T Date.now() sont. L'exception est que Date et now() les temps ne se mélangent pas, comme Date est basé sur Unix-époque (le nombre de millisecondes depuis 1970), now() est le nombre de millisecondes depuis le début de la navigation de votre page (il sera donc beaucoup plus petit que Date).

Voici un exemple d'utilisation now():

function a() {
  var start = window.performance.now();
   ... do stuff ...
  var end = window.performance.now();
  var dur = end - start;
}

now() est pris en charge dans Chrome stable, Firefox 15+ et IE10. Il y a aussi plusieurs polyfills disponible.

Une autre option pour mesurer le temps d'exécution dans la nature est UserTiming. UserTiming se comporte de la même manière que console.time() et console.timeEnd(), mais il utilise le même horodatage haute résolution que now() utilise (donc vous obtenez une horloge sous-milliseconde monotone croissante), et enregistre les horodatages et les durées à la PerformanceTimeline.

UserTiming a les concepts de des notes (horodateurs) et les mesures (durées). Vous pouvez en définir autant que vous le souhaitez, et ils sont exposés sur le PerformanceTimeline.

Pour enregistrer un horodatage, vous appelez mark(startMarkName). Pour obtenir la durée depuis votre première marque, vous appelez simplement measure(measurename, startMarkname). La durée est ensuite enregistrée dans la PerformanceTimeline à côté de vos marques.

function a() {
  window.performance.mark("start");
  ... do stuff ...
  window.performance.measure("myfunctionduration", "start");
}

// duration is window.performance.getEntriesByName("myfunctionduration", "measure")[0];

UserTiming est disponible dans IE10 + et Chrome25 +. Il y a aussi polyfill disponible (que j'ai écrit).


44
2018-01-14 19:01



Pour obtenir des valeurs précises, vous devez utiliser Interface de performance. Il est pris en charge dans les versions modernes de Firefox, Chrome, Opera et IE. Voici un exemple de la façon dont il peut être utilisé:

var performance = window.performance;
var t0 = performance.now();
doWork();
var t1 = performance.now();
console.log("Call to doWork took " + (t1 - t0) + " milliseconds.")

Date.getTime() ou console.time() ne sont pas bons pour mesurer le temps d'exécution précis. Vous pouvez les utiliser si l'estimation rapide rapide est OK pour vous. Par estimation grossière, je veux dire que vous pouvez obtenir un décalage de 15-60 ms par rapport au temps réel.

Vérifiez ce brillant poster sur la mesure du temps d'exécution en JavaScript. L'auteur donne également quelques liens sur la précision du temps JavaScript, qui vaut la peine d'être lu.


28
2018-02-26 16:13



Utilisez Firebug, activez à la fois la console et Javascript. Cliquez sur Profil. Recharger. Cliquez à nouveau sur Profil. Voir le rapport


17
2017-11-24 11:14



var StopWatch = function (performance) {
    this.startTime = 0;
    this.stopTime = 0;
    this.running = false;
    this.performance = performance === false ? false : !!window.performance;
};

StopWatch.prototype.currentTime = function () {
    return this.performance ? window.performance.now() : new Date().getTime();
};

StopWatch.prototype.start = function () {
    this.startTime = this.currentTime();
    this.running = true;
};

StopWatch.prototype.stop = function () {
    this.stopTime = this.currentTime();
    this.running = false;
};

StopWatch.prototype.getElapsedMilliseconds = function () {
    if (this.running) {
        this.stopTime = this.currentTime();
    }

    return this.stopTime - this.startTime;
};

StopWatch.prototype.getElapsedSeconds = function () {
    return this.getElapsedMilliseconds() / 1000;
};

StopWatch.prototype.printElapsed = function (name) {
    var currentName = name || 'Elapsed:';

    console.log(currentName, '[' + this.getElapsedMilliseconds() + 'ms]', '[' + this.getElapsedSeconds() + 's]');
};

Référence

var stopwatch = new StopWatch();
stopwatch.start();

for (var index = 0; index < 100; index++) {
    stopwatch.printElapsed('Instance[' + index + ']');
}

stopwatch.stop();

stopwatch.printElapsed();

Sortie

Instance[0] [0ms] [0s]
Instance[1] [2.999999967869371ms] [0.002999999967869371s]
Instance[2] [2.999999967869371ms] [0.002999999967869371s]
/* ... */
Instance[99] [10.999999998603016ms] [0.010999999998603016s]
Elapsed: [10.999999998603016ms] [0.010999999998603016s]

performance.now () est optionnel - il suffit de passer false dans la fonction constructeur StopWatch.


10
2017-08-08 18:54



process.hrtime () est disponible dans Node.js - il renvoie une valeur en nanosecondes

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

9
2018-03-11 09:49



Pour étendre le code de vsync pour avoir la possibilité de renvoyer le timeEnd comme valeur dans NodeJS, utilisez ce petit morceau de code.

console.timeEndValue = function(label) { // Add console.timeEndValue, to add a return value
   var time = this._times[label];
   if (!time) {
     throw new Error('No such label: ' + label);
   }
   var duration = Date.now() - time;
   return duration;
};

Maintenant, utilisez le code comme ceci:

console.time('someFunction timer');

someFunction();

var executionTime = console.timeEndValue('someFunction timer');
console.log("The execution time is " + executionTime);


Cela vous donne plus de possibilités. Vous pouvez stocker le temps d'exécution à utiliser à d'autres fins, comme l'utiliser dans des équations, ou stocké dans une base de données, envoyé à un client distant sur des Websockets, servi sur une page Web, etc.


7
2017-08-04 04:23