Comment mesurer le temps mis par une fonction pour s'exécuter

J'ai besoin d'obtenir le temps d'exécution en millisecondes.

J'ai initialement posé cette question en 2008. La réponse acceptée était alors d'utiliser la nouvelle Date (). GetTime () Cependant, nous pouvons tous convenir maintenant que l'utilisation de l' API standard performance.now () est plus appropriée. Je modifie donc la réponse acceptée à celle-ci.

Utilisation de performance.now () :

var t0 = performance.now()

doSomething()   // <---- The function you're measuring time for 

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

NodeJs: il est nécessaire d' importer laperformance classe

Utilisation de console.time :(non standard)( niveau de vie )

console.time('someFunction')

someFunction() // Whatever is timed goes between the two "console.time"

console.timeEnd('someFunction')

Remarque :
La chaîne transmise auxméthodestime()ettimeEnd()doit correspondre
(pour que la minuterie se termine comme prévu).

console.time() documentations:

1. Documentation NodeJS concernant
2. Documentation MDN (côté client)

utilisez new Date (). getTime ()

La méthode getTime () renvoie le nombre de millisecondes 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);

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

Utilisationperformance.now() :

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

Il fonctionne sur:

• IE 10 ++

• FireFox 15 ++

• Chrome 24 ++

• Safari 8 ++

• Opera 15 ++

• Android 4.4 ++

• etc

console.timepeut être viable pour vous , mais ce n'est pas standard § :

Cette fonctionnalité n'est pas standard et n'est pas conforme aux normes. Ne l'utilisez pas sur des sites de production face au Web: cela ne fonctionnera pas pour tous les utilisateurs. Il peut également y avoir de grandes incompatibilités entre les implémentations et le comportement peut changer à l'avenir.

Outre la prise en charge du navigateur, performance.nowsemble avoir le potentiel de fournir des timings plus précis car il semble que ce soit la version simple de console.time.

<rant> Aussi, NE JAMAIS utiliser Datepour quoi que ce soit car il est affecté par les changements de "l'heure système". Ce qui signifie que nous allons obtenir des résultats invalides -comme « timing négatif » - lorsque l'utilisateur ne dispose pas d' un temps de système précis:

En octobre 2014, l'horloge de mon système s'est détraquée et devinez quoi ... J'ai ouvert Gmail et vu tous les e-mails de ma journée "envoyés il y a 0 minutes ". Et je pensais que Gmail était censé être construit par des ingénieurs de classe mondiale de Google .......

(Réglez votre horloge système sur un an et accédez à Gmail pour que nous puissions tous bien rire. Peut-être qu'un jour nous aurons un Hall of Shame pour JS Date.)

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

La seule fois que vous utiliserez, Datec'est quand vous voulez montrer à l'utilisateur l' heure de son horloge système. Pas quand vous voulez avoir le temps ou mesurer quoi que ce soit.

Si vous devez 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 devraient donner la mesure la plus précise car vous n'avez pas à modifier votre code existant, ce qui pourrait affecter le temps d'exécution de la fonction.

Pour profiler votre JavaScript:

• Dans Chrome , appuyez sur F12 et sélectionnez l' onglet Profils , puis Collecter le profil CPU JavaScript .
• Dans Firefox , installez / ouvrez Firebug et cliquez sur le bouton Profil .
• Dans IE 9+ , appuyez sur F12 , cliquez sur Script ou Profiler (selon votre version d'IE).

Alternativement, sur votre machine de développement , vous pouvez ajouter une instrumentation à votre code avec console.time()et console.timeEnd(). Ces fonctions, prises en charge dans Firefox11 +, Chrome2 + et IE11 +, rendent compte des minuteries via lesquelles vous démarrez / arrêtez console.time(). time()prend comme argument un nom de temporisateur défini par l'utilisateur, timeEnd()puis rend compte du temps d'exécution depuis le démarrage du temporisateur:

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 l' timeEnd()appel. Les autres navigateurs signalent simplement le résultat à la console développeur: la valeur de retour de timeEnd()n'est pas définie.

Si vous souhaitez 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, l' Dateobjet n'a qu'une résolution en millisecondes et sera affecté par les modifications d'horloge système de tout système d'exploitation. Dans les navigateurs modernes, il existe 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 submilliseconde 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 de 1 seconde et 123 microsecondes).

2. now()augmente de façon monotone. Ceci est important car il Date.getTime()peut éventuellement avancer ou même reculer lors des appels suivants. Notamment, si l'heure système du système d'exploitation est mise à jour (par exemple la synchronisation de l'horloge atomique), Date.getTime()est également mise à jour. now()est garanti d'être toujours en augmentation monotone, il n'est donc pas affecté par l'heure système du système d'exploitation - 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 qui new Date().getTime(), + new Dateett Date.now()sont. L'exception est que Dateet les now()temps ne se mélangent pas, comme Datese base sur unix-époque (le nombre de millisecondes depuis 1970), alors que now()le nombre de millisecondes depuis votre page de navigation a commencé (il sera 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 existe également plusieurs polyfills disponibles.

UserTiming est une autre option pour mesurer le temps d'exécution dans la nature . 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 celui now()utilisé (vous obtenez donc une horloge augmentant de façon monotone de moins d'une milliseconde) et enregistre les horodatages et les durées dans PerformanceTimeline .

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

Pour enregistrer un horodatage, vous appelez mark(startMarkName). Pour obtenir la durée depuis votre première note, il vous suffit d'appeler measure(measurename, startMarkname). La durée est ensuite enregistrée dans PerformanceTimeline à côté de vos repères.

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 existe également un polyfill disponible (que j'ai écrit).

Pour obtenir des valeurs précises, vous devez utiliser l' interface 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 un temps d'exécution précis. Vous pouvez les utiliser si une estimation rapide et approximative vous convient. Par estimation approximative, je veux dire que vous pouvez obtenir un décalage de 15 à 60 ms par rapport au temps réel.

Vérifiez ce brillant après sur la mesure du temps d'exécution en JavaScript. L'auteur donne également quelques liens sur la précision de l'heure JavaScript, à lire.

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

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();

Production

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 facultatif - passez simplement false dans la fonction constructeur StopWatch.

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

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

vous pouvez également utiliser l'opérateur d'ajout ici

 var start = +new Date();
 callYourFunctionHere();
 var end = +new Date();
 var time = end - start;
 console.log('total execution time = '+ time + 'ms');

Pour étendre davantage le code de vsync pour avoir la possibilité de renvoyer le timeEnd en tant que 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 pour être utilisé à d'autres fins, comme l'utiliser dans des équations, ou stocké dans une base de données, envoyé à un client distant via des sockets Web, servi sur une page Web, etc.

Il est possible d'utiliser une seule variable:

var timer = -performance.now();

// Do something

timer += performance.now();
console.log("Time: " + (timer/1000).toFixed(5) + " sec.")

timer/1000 - pour convertir des millisecondes en secondes

.toFixed(5) - pour couper des chiffres supplémentaires

Depuis console.timeet performance.nowne sont pas pris en charge dans certains principaux navigateurs (ie IE10), j'ai créé un utilitaire slim qui utilise les meilleures méthodes disponibles. Cependant, il manque de gestion des erreurs pour les fausses utilisations (appel End()à un temporisateur non initialisé).

Utilisez-le et améliorez-le comme vous le souhaitez.

Performance: {
    Timer: {},
    Start: function (name) {
        if (console && console.time) {
            console.time(name);
        } else if (window.performance.now) {
            this.Timer[name] = window.performance.now();
        } else {
            this.Timer[name] = new Date().getTime();
        }
    },
    End: function (name) {
        if (console && console.time) {
            console.timeEnd(name);
        } else {
            var result;
            if (window.performance.now) {
                result = window.performance.now() - this.Timer[name];
            } else {
                result = new Date().getTime() - this.Timer[name];
            }
            console.log(name + ": " + result);
        }
    }
}

Cela peut vous aider.

var t0 = date.now(); doSomething(); var t1 = date.now(); console.log("Call to doSomething took approximate" + (t1 - t0)/1000 + " seconds.")

Voici un décorateur pour les fonctions de synchronisation

let timed = (f) => (...args)=>{
    let start = performance.now();
    let ret = f(...args);
    console.log(`function ${f.name} took ${(performance.now()-start).toFixed(3)}ms`)
    return ret;   
}

Usage:

let test = ()=>{/*does something*/}
test = timed(test)   // turns the function into a timed function in one line
test()               // run your code as normal, logs 'function test took 1001.900ms' 

Si vous utilisez des fonctions asynchrones, vous pouvez faire de l' timedasync et ajouter un awaitavant f (... args), et cela devrait fonctionner pour celles-ci. Cela devient plus compliqué si vous voulez qu'un décorateur gère les fonctions de synchronisation et d'async.

Merci, Achim Koellner, développera un peu votre réponse:

var t0 = process.hrtime();
//Start of code to measure

//End of code
var timeInMilliseconds = process.hrtime(t0)[1]/1000000; // dividing by 1000000 gives milliseconds from nanoseconds

Veuillez noter que vous ne devez rien faire à part ce que vous voulez mesurer (par exemple, console.log prendra également du temps à exécuter et affectera les tests de performances).

Notez que dans l'ordre par mesure du temps d'exécution des fonctions asynchrones, vous devez insérer var timeInMilliseconds = process.hrtime(t0)[1]/1000000;à l'intérieur du rappel. Par exemple,

var t0 = process.hrtime();
someAsyncFunction(function(err, results) {
var timeInMilliseconds = process.hrtime(t0)[1]/1000000;

});

Il y a quelques mois, j'ai créé ma propre routine qui chronomètre une fonction en utilisant Date.now () - même si à l'époque la méthode acceptée semblait être performance.now () - parce que l'objet de performance n'est pas encore disponible (construit -in) dans la version stable de Node.js.

Aujourd'hui, je faisais plus de recherches et j'ai trouvé une autre méthode de chronométrage. Puisque j'ai également trouvé comment utiliser cela dans le code Node.js, j'ai pensé que je le partagerais ici.

Les éléments suivants sont combinés à partir des exemples donnés par w3c et Node.js :

function functionTimer() {
    performance.mark('start')
    functionToBeTimed()
    performance.mark('end')
    performance.measure('Start to End', 'start', 'end')
    const measure = performance.getEntriesByName('Start to End')[0]
    console.log(measure.duration)
}

REMARQUE:

Si vous avez l'intention d'utiliser l' performanceobjet dans une application Node.js, vous devez inclure les éléments suivants: const { performance } = require('perf_hooks')

il existe plusieurs façons d'atteindre cet objectif:

1. en utilisant console.time

   console.time('function');
   //run the function in between these two lines for that you need to 
   //measure time taken by the function. ("ex. function();")
   console.timeEnd('function');

2. c'est le moyen le plus efficace: utiliser performance.now () , par exemple

   var v1 = performance.now();
   //run the function here for which you have top measure the time 
   var v2 = performance.now();
   console.log("total time  taken = "+(v2-v1)+"milliseconds");

3. utilisez + (ajouter un opérateur) ou getTime ()

   var h2 = +new Date(); //or
   var h2 = new Date().getTime();
   for(i=0;i<500;i++) { /* do something */}
   var h3 = +new Date();   //or 
   var h3 = new Date().getTime();
   var timeTaken = h3-h2;
   console.log("time ====", timeTaken);

Voici ce qui se passe lorsque vous appliquez l'opérateur unaire plus à une instance de date: Obtenez la valeur de l'instance de date en question Convertissez-la en nombre

REMARQUE: getTime()donne de meilleures performances que l'opérateur unaire +.

export default class Singleton {

  static myInstance: Singleton = null;

  _timers: any = {};

  /**
   * @returns {Singleton}
   */
  static getInstance() {
    if (Singleton.myInstance == null) {
      Singleton.myInstance = new Singleton();
    }

    return this.myInstance;
  }

  initTime(label: string) {
    this._timers[label] = Date.now();
    return this._timers[label];
  }

  endTime(label: string) {
    const endTime = Date.now();
    if (this._timers[label]) {
      const delta = endTime - this._timers[label];
      const finalTime = `${label}: ${delta}ms`;
      delete this._timers[label];
      return finalTime;
    } else {
      return null;
    }
  }
}

InitTime lié à string.

return Singleton.getInstance().initTime(label); // Returns the time init

return Singleton.getInstance().endTime(label); // Returns the total time between init and end

Si vous voulez mesurer le temps entre plusieurs choses qui ne sont pas imbriquées, vous pouvez utiliser ceci:

function timer(lap){ 
    if(lap) console.log(`${lap} in: ${(performance.now()-timer.prev).toFixed(3)}ms`); 
    timer.prev = performance.now();
}

Similaire à console.time (), mais une utilisation plus facile si vous n'avez pas besoin de garder une trace des minuteries précédentes.

Si vous aimez la couleur bleue de console.time (), vous pouvez utiliser cette ligne à la place

console.log(`${lap} in: %c${(performance.now()-timer.prev).toFixed(3)}ms`, 'color:blue');

// Usage: 
timer()              // set the start
// do something 
timer('built')       // logs 'built in: 591.815ms'
// do something
timer('copied')      // logs 'copied in: 0.065ms'
// do something
timer('compared')    // logs 'compared in: 36.41ms'

Dans mon cas, je préfère utiliser @ grammar suger et le compiler avec babel.
Le problème de cette méthode est que la fonction doit être à l'intérieur de l'objet.

Exemple de code JS

function timer() {
    return (target, propertyKey, descriptor) => {
        const start = Date.now();
        let oldFunc = descriptor.value;

        descriptor.value = async function (){
            var result = await oldFunc.apply(this, arguments);
            console.log(Date.now() - start);
            return result;
        }
    }
}

// Util function 
function delay(timeout) {
    return new Promise((resolve) => setTimeout(() => {
        resolve();
    }, timeout));
}

class Test {
    @timer()
    async test(timout) {
        await delay(timout)
        console.log("delay 1");
        await delay(timout)
        console.log("delay 2");
    }
}

const t = new Test();
t.test(1000)
t.test(100)

.babelrc (pour babel 6)

 {
    "plugins": [
        "transform-decorators-legacy"
    ]
 }

Chronomètre avec cycles cumulatifs

Fonctionne avec serveur et client (Node ou DOM), utilise l' PerformanceAPI. Bien lorsque vous avez de nombreux petits cycles, par exemple dans une fonction appelée 1000 fois qui traite 1000 objets de données, mais que vous voulez voir comment chaque opération dans cette fonction s'ajoute au total.

Donc celui-ci utilise une minuterie globale (singleton) de module. Identique à un modèle de classe singleton, juste un peu plus simple à utiliser, mais vous devez le mettre dans un stopwatch.jsfichier eg séparé .

const perf = typeof performance !== "undefined" ? performance : require('perf_hooks').performance;
const DIGITS = 2;

let _timers = {};

const _log = (label, delta?) => {
    if (_timers[label]) {
        console.log(`${label}: ` + (delta ? `${delta.toFixed(DIGITS)} ms last, ` : '') +
            `${_timers[label].total.toFixed(DIGITS)} ms total, ${_timers[label].cycles} cycles`);
    }
};

export const Stopwatch = {
    start(label) {
        const now = perf.now();
        if (_timers[label]) {
            if (!_timers[label].started) {
                _timers[label].started = now;
            }
        } else {
            _timers[label] = {
                started: now,
                total: 0,
                cycles: 0
            };
        }
    },
    /** Returns total elapsed milliseconds, or null if stopwatch doesn't exist. */
    stop(label, log = false) {
        const now = perf.now();
        if (_timers[label]) {
            let delta;
            if(_timers[label].started) {
                delta = now - _timers[label].started;
                _timers[label].started = null;
                _timers[label].total += delta;
                _timers[label].cycles++;
            }
            log && _log(label, delta);
            return _timers[label].total;
        } else {
            return null;
        }
    },
    /** Logs total time */
    log: _log,
    delete(label) {
        delete _timers[label];
    }
};

La meilleure façon serait d'utiliser le performance hooksmodule. Bien instable, vous pouvez les markzones spécifiques de votre code et measureles durationentre les zones marquées.

const { performance, PerformanceObserver } = require('perf_hooks');

const measures = []

const obs = new PerformanceObserver(list => measures.push(...list.getEntries()));
obs.observe({ entryTypes: ['measure'] });
const getEntriesByType = cb => cb(measures);

const doSomething = val => {
  performance.mark('beginning of the process');

  val *= 2;

  performance.mark('after multiplication');

  performance.measure('time taken', 'beginning of the process', 'after multiplication');

  getEntriesByType(entries => {
    entries.forEach(entry => console.log(entry));
  })

  return val;
}

doSomething(4);

Essayez ici

const { performance } = require('perf_hooks');

function addUpTo(n) {
  let total = 0;
  for (let i = 1; i <= n; i++) {
    total += i;
  }
  return total;
}


let t1 = performance.now();
addUpTo(1000000000);
let t2 = performance.now();
console.log(`Time elapsed: ${(t2 - t1) / 1000} seconds`);
// Time elapsed: 1.1261566010713577 seconds

Avec performance

NodeJs: il est nécessaire d'importer la classe de performances

var time0 = performance.now(); // Store the time at this point into time0

yourFunction();   // The function you're measuring time for 

var time1 = performance.now(); // Store the time at this point into time1

console.log("youFunction took " + (time1 - time0) + " milliseconds to execute");

Utilisation de console.time

console.time('someFunction');

someFunction(); // Whatever is timed goes between the two "console.time"

console.timeEnd('someFunction');

1. Pour démarrer la minuterie, utilisezconsole.time("myTimer");
2. Facultatif: pour imprimer le temps écoulé, utilisez console.timeLog("myTimer");
3. Enfin, pour arrêter le chronomètre et imprimer l'heure finale:console.timeEnd("myTimer");

Vous pouvez en savoir plus à ce sujet sur MDN et dans la documentation Node.js .

Disponible sur Chrome, Firefox, Opera et NodeJS. (pas sur Edge ou Internet Explorer).

Comme indiqué précédemment, vérifiez et utilisez la minuterie intégrée. Mais si vous voulez ou devez écrire le vôtre, voici mes deux cents:

//=-=|Source|=-=//
/**
 * JavaScript Timer Object
 *
 *      var now=timer['elapsed'](); 
 *      timer['stop']();
 *      timer['start']();
 *      timer['reset']();
 * 
 * @expose
 * @method timer
 * @return {number}
 */
timer=function(){
    var a=Date.now();
    b=0;
    return{
        /** @expose */
        elapsed:function(){return b=Date.now()-a},
        start:function(){return a=Date.now()},
        stop:function(){return Date.now()},
        reset:function(){return a=0}
    }
}();

//=-=|Google Advanced Optimized|=-=//
timer=function(){var a=Date.now();b=0;return{a:function(){return b=Date.now()-a},start:function(){return a=Date.now()},stop:function(){return Date.now()},reset:function(){return a=0}}}();

La compilation a été un succès!

• Taille d'origine: 219 octets compressés (405 octets non compressés)
• Taille compilée: 109 octets compressés (187 octets non compressés)
• Économisez 50,23% sur la taille gzippée (53,83% sans gzip

La réponse acceptée est fausse !

Puisque JavaScript est asynchrone, les valeurs de l'extrémité variable de la réponse acceptée seraient erronées.

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

for (i = 0; i < 50000; ++i) {
// JavaScript is not waiting until the for is finished !!
}

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

L'exécution de for peut être très rapide, vous ne pouvez donc pas voir que le résultat est incorrect. Vous pouvez le tester avec un code faisant une requête:

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

for (i = 0; i < 50000; ++i) {
  $.ajax({
    url: 'www.oneOfYourWebsites.com',
    success: function(){
       console.log("success");
    }
  });
}

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

L'alerte sera donc très rapide, mais dans la console, vous verrez que les requêtes ajax se poursuivent.

Voici comment vous devez le faire: https://developer.mozilla.org/en-US/docs/Web/API/Performance.now