Cómo medir el tiempo que tarda una función en ejecutarse

Necesito obtener el tiempo de ejecución en milisegundos.

Originalmente hice esta pregunta en 2008. La respuesta aceptada era usar la nueva Fecha (). GetTime () Sin embargo, ahora todos podemos estar de acuerdo en que usar la API estándar performance.now () es más apropiado. Por lo tanto, estoy cambiando la respuesta aceptada a esta.

Usando 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: se requiere para importar laperformance clase

Usando console.time :(no estándar)( nivel de vida )

console.time('someFunction')

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

console.timeEnd('someFunction')

Nota :
La cadena que se pasa a losmétodostime()ytimeEnd()debe coincidir
(para que el temporizador termine como se esperaba).

console.time() documentaciones:

1. Documentación de NodeJS sobre
2. Documentación de MDN (del lado del cliente)

use new Date (). getTime ()

El método getTime () devuelve el número de milisegundos desde la medianoche del 1 de enero de 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);

No use Fecha (). Lee abajo.

Usoperformance.now() :

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

Funciona en:

• IE 10 ++

• FireFox 15 ++

• Chrome 24 ++

• Safari 8 ++

• Opera 15 ++

• Android 4.4 ++

• etcétera etcétera

console.timepuede ser viable para usted , pero no es estándar § :

Esta característica no es estándar y no está en una pista estándar. No lo use en sitios de producción orientados a la Web: no funcionará para todos los usuarios. También puede haber grandes incompatibilidades entre implementaciones y el comportamiento puede cambiar en el futuro.

Además del soporte del navegador, performance.nowparece tener el potencial de proporcionar tiempos más precisos, ya que parece ser la versión básica console.time.

<rant> Además, NUNCA lo use Datepara nada porque está afectado por cambios en el "tiempo del sistema". Lo que significa que vamos a obtener resultados válidos -como "el momento negativo" - cuando el usuario no tiene un tiempo del sistema exacto:

En octubre de 2014, mi reloj del sistema se volvió loco y adivina qué ... Abrí Gmail y vi todos los correos electrónicos de mi día "enviados hace 0 minutos ". Y pensé que se suponía que Gmail debía ser construido por ingenieros de primer nivel de Google ...

(Configure el reloj de su sistema hace un año y vaya a Gmail para que todos podamos reírnos. Quizás algún día tengamos un Salón de la Vergüenza para JS Date).

La now()función de hoja de cálculo de Google también sufre este problema.

El único momento que usará Datees cuando desea mostrarle al usuario la hora del reloj de su sistema. No cuando quieres tener el tiempo o medir algo.

Si necesita obtener el tiempo de ejecución de la función en su máquina de desarrollo local , puede usar las herramientas de creación de perfiles de su navegador o comandos de consola como console.time()y console.timeEnd().

Todos los navegadores modernos tienen perfiles de JavaScript incorporados. Estos perfiladores deberían proporcionar la medición más precisa ya que no tiene que modificar su código existente, lo que podría afectar el tiempo de ejecución de la función.

Para perfilar tu JavaScript:

• En Chrome , presione F12 y seleccione la pestaña Perfiles , luego Recopilar perfil de CPU de JavaScript .
• En Firefox , instale / abra Firebug y haga clic en el botón Perfil .
• En IE 9+ , presione F12 , haga clic en Script o Profiler (dependiendo de su versión de IE).

Alternativamente, en su máquina de desarrollo , puede agregar instrumentación a su código con console.time()y console.timeEnd(). Estas funciones, compatibles con Firefox11 +, Chrome2 + e IE11 +, informan sobre los temporizadores a través de los cuales usted inicia / detiene console.time(). time()toma un nombre de temporizador definido por el usuario como argumento y timeEnd()luego informa sobre el tiempo de ejecución desde que se inició el temporizador:

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

Tenga en cuenta que solo Firefox devuelve el tiempo transcurrido en la timeEnd()llamada. Los otros navegadores simplemente informan el resultado a la consola del desarrollador: el valor de retorno de timeEnd()no está definido.

Si desea obtener el tiempo de ejecución de la función en la naturaleza , deberá instrumentar su código. Usted tiene un par de opciones. Simplemente puede guardar las horas de inicio y finalización consultando new Date().getTime():

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

Sin embargo, el Dateobjeto solo tiene una resolución de milisegundos y se verá afectado por los cambios en el reloj del sistema operativo de cualquier sistema operativo. En los navegadores modernos, hay una mejor opción.

La mejor opción es usar el tiempo de alta resolución , también conocido como window.performance.now(). now()es mejor que el tradicional Date.getTime()en dos formas importantes:

1. now()es una resolución doble con submilisegundos que representa el número de milisegundos desde el inicio de la navegación de la página. Devuelve el número de microsegundos en el fraccional (por ejemplo, un valor de 1000.123 es 1 segundo y 123 microsegundos).

2. now()Está aumentando monotónicamente. Esto es importante ya Date.getTime()que posiblemente puede saltar hacia adelante o incluso hacia atrás en llamadas posteriores. En particular, si la hora del sistema del sistema operativo se actualiza (por ejemplo, la sincronización del reloj atómico), Date.getTime()también se actualiza. now()está garantizado que siempre aumentará monotónicamente, por lo que no se verá afectado por la hora del sistema del sistema operativo; siempre será la hora del reloj de pared (suponiendo que su reloj de pared no sea atómico ...).

now()se puede usar en casi todos los lugares new Date().getTime(), + new Datey lo Date.now()son. La excepción es que Datey los now()tiempos no se mezclan, ya que Datese basa en unix-epoch (el número de milisegundos desde 1970), mientras quenow() es el número de milisegundos desde que comenzó la navegación de su página (por lo que será mucho menor que Date).

Aquí hay un ejemplo de cómo usar now():

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

now()es compatible con Chrome estable, Firefox 15+ e IE10. También hay varios polyfills disponibles.

Otra opción para medir el tiempo de ejecución en la naturaleza es UserTiming . UserTiming se comporta de manera similar a console.time()y console.timeEnd(), pero utiliza la misma marca de tiempo de alta resolución que now()usa (por lo que obtiene un reloj que aumenta monotónicamente por debajo de milisegundos), y guarda las marcas de tiempo y duraciones en el PerformanceTimeline .

UserTiming tiene los conceptos de marcas ( marcas de tiempo) y medidas (duraciones). Puede definir tantos como desee, y se exponen en PerformanceTimeline .

Para guardar una marca de tiempo, llame mark(startMarkName). Para obtener la duración desde su primera marca, simplemente llame measure(measurename, startMarkname). La duración se guarda en PerformanceTimeline junto con sus marcas.

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

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

UserTiming está disponible en IE10 + y Chrome25 +. También hay un polyfill disponible (que escribí).

Para obtener valores precisos, debe usar la interfaz de rendimiento . Es compatible con las versiones modernas de Firefox, Chrome, Opera e IE. Aquí hay un ejemplo de cómo se puede usar:

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

Date.getTime() o console.time() no son buenos para medir el tiempo de ejecución preciso. Puede usarlos si el cálculo aproximado rápido está bien para usted. Por estimación aproximada quiero decir que puede obtener un cambio de 15-60 ms del tiempo real.

Consulte esta brillante publicación sobre la medición del tiempo de ejecución en JavaScript. El autor también ofrece un par de enlaces sobre la precisión del tiempo de JavaScript, que vale la pena leer.

Usa Firebug, habilita tanto la consola como Javascript. Haz clic en Perfil. Recargar. Haga clic en Perfil nuevamente. Ver el informe

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]');
};

Punto de referencia

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

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

stopwatch.stop();

stopwatch.printElapsed();

Salida

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 () es opcional; simplemente pase false a la función de constructor StopWatch.

process.hrtime () está disponible en Node.js : devuelve un valor en nanosegundos

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

puedes usar agregar operador también aquí

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

Para extender aún más el código de vsync para tener la capacidad de devolver el tiempo final como un valor en NodeJS, use este pequeño fragmento de código.

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;
};

Ahora usa el código así:

console.time('someFunction timer');

someFunction();

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

Esto te da más posibilidades. Puede almacenar el tiempo de ejecución para usarlo con más fines, como usarlo en ecuaciones, o almacenarlo en una base de datos, enviarlo a un cliente remoto a través de sockets web, servirlo en una página web, etc.

Es posible usar solo una variable:

var timer = -performance.now();

// Do something

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

timer/1000 - convertir milisegundos a segundos

.toFixed(5) - para recortar dígitos adicionales

Desde entonces console.timey performance.nowno son compatibles con algunos de los principales navegadores (es decir, IE10), creé una utilidad delgada que utiliza los mejores métodos disponibles. Sin embargo, carece de manejo de errores para usos falsos (llamando End()a un temporizador no inicializado).

Úsalo y mejóralo como quieras.

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

Te puede ayudar.

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

Aquí hay un decorador para funciones de temporización

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;   
}

Uso:

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 está utilizando funciones asíncronas, puede hacer timedasíncrono y agregar un awaitantes f (... args), y eso debería funcionar para ellos. Se vuelve más complicado si desea que un decorador maneje las funciones de sincronización y asíncrona.

Gracias, Achim Koellner, ampliará un poco su respuesta:

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

Tenga en cuenta que no debe hacer nada aparte de lo que desea medir (por ejemplo, console.log también llevará tiempo ejecutarlo y afectará las pruebas de rendimiento).

Tenga en cuenta que, en orden por medida de tiempo de ejecución de funciones asíncronas, debe insertar var timeInMilliseconds = process.hrtime(t0)[1]/1000000;dentro de la devolución de llamada. Por ejemplo,

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

});

Hace un par de meses, armé mi propia rutina que sincroniza una función usando Date.now (), aunque en ese momento el método aceptado parecía ser performance.now (), porque el objeto de rendimiento aún no está disponible (construido -in) en la versión estable de Node.js.

Hoy estaba investigando un poco más y encontré otro método para medir el tiempo. Como también encontré cómo usar esto en el código Node.js, pensé en compartirlo aquí.

Lo siguiente se combina de los ejemplos dados por w3c y 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)
}

NOTA:

Si tiene la intención de utilizar el performanceobjeto en una aplicación Node.js, debe incluir los siguientes requisitos: const { performance } = require('perf_hooks')

Hay varias formas de lograr este objetivo:

1. usando 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. esta es la forma más eficiente: usando performance.now () , por ejemplo

   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. use + (agregar operador) o 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);

Esto es lo que sucede cuando aplica el operador unario más a una instancia de Fecha: Obtenga el valor de la instancia de Fecha en cuestión Conviértalo en un Número

NOTA: getTime()ofrece un mejor rendimiento que el operador unario +.

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 relacionado con string.

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

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

Si desea medir el tiempo entre varias cosas que no están anidadas, puede usar esto:

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

Similar a console.time (), pero de uso más fácil si no necesita hacer un seguimiento de los temporizadores anteriores.

Si le gusta el color azul de console.time (), puede usar esta línea en su lugar

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'

En mi caso, prefiero usar @ grammar suger y compilarlo con babel.
El problema de este método es que la función tiene que estar dentro del objeto.

Código JS de muestra

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 (para babel 6)

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

Cronómetro con ciclos acumulativos

Funciona con servidor y cliente (Nodo o DOM), utiliza el Performance API. Es bueno cuando tiene muchos ciclos pequeños, por ejemplo, en una función llamada 1000 veces que procesa 1000 objetos de datos pero desea ver cómo cada operación en esta función se suma al total.

Entonces este usa un temporizador global de módulo (singleton). Igual que un patrón singleton de clase, un poco más simple de usar, pero debe ponerlo en un stopwatch.jsarchivo separado, por ejemplo .

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 mejor manera sería usar el performance hooksmódulo. Aunque inestable, puede markáreas específicas de su código y measureel durationentre las áreas marcadas.

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

Intenta aqui

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

Con rendimiento

NodeJs: se requiere para importar la clase de rendimiento

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

Usando console.time

console.time('someFunction');

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

console.timeEnd('someFunction');

1. Para iniciar el temporizador useconsole.time("myTimer");
2. Opcional: para imprimir el tiempo transcurrido, use console.timeLog("myTimer");
3. Finalmente, para detener el temporizador e imprimir la hora final:console.timeEnd("myTimer");

Puede leer más sobre esto en MDN y en la documentación de Node.js .

Disponible en Chrome, Firefox, Opera y NodeJS. (no en Edge o Internet Explorer).

Como se indicó anteriormente, verifique y use el temporizador incorporado. Pero si quieres o necesitas escribir el tuyo aquí están mis dos centavos:

//=-=|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 compilación fue un éxito!

• Tamaño original: 219 bytes comprimidos (405 bytes sin comprimir)
• Tamaño compilado: 109 bytes comprimidos (187 bytes sin comprimir)
• Ahorró 50.23% del tamaño comprimido (53.83% sin gzip

¡La respuesta aceptada es incorrecta !

Dado que JavaScript es asíncrono, los valores del extremo variable de la respuesta aceptada serían incorrectos.

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

La ejecución de for puede ser muy rápida, por lo que no puede ver que el resultado es incorrecto. Puede probarlo con un código haciendo alguna solicitud:

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

Por lo tanto, la alerta se activará rápidamente, pero en la consola verá que las solicitudes de ajax continúan.

Así es como debes hacerlo: https://developer.mozilla.org/en-US/docs/Web/API/Performance.now