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

1192

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.

Julio A
fuente
3
A menudo, una declaración sobre lo que está tratando de lograr con el tiempo de ejecución puede resultar mucho más útil que responder la pregunta solo. En estos días, el uso de herramientas de creación de perfiles en Firebug o Chrome Dev es a menudo una forma mucho mejor de encontrar el código que está absorbiendo su jugo de CPU.
oligofren
así es como puedes hacerlo de la Datemanera clásica , que te da msy es suficiente para la mayoría de los casos, creo que albertech.blogspot.com/2015/07/… ... pero sí, realmente deberías mirarPerformance.now
jar
55
performance.now()No funciona en el nodo. new Date().getTime()Trabajará en Nodo.
Ryan Walker
1
número 1000 upvote woop woop: D
Kiksen
1
@oligofren: a veces es posible que desee capturar estos datos. Tengo una situación en la que estoy escribiendo esto para IndexedDB
ThomasRones

Respuestas:

1757

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)
vsync
fuente
27
Ahora también es compatible con las Herramientas para desarrolladores de Chrome.
julien_c
3
Esta es actualmente la mejor manera de recopilar tiempos precisos de lo que entiendo.
Ash Blue
66
¿No necesitas ejecutar la función entre esas dos declaraciones? Ahora mide el tiempo que lleva definirlo, no ejecutarlo. Corrígeme si me equivoco ...
Cristian
2
Enlace al artículo de MDN sobre esta característica: developer.mozilla.org/en-US/docs/DOM/console.time
nulabilidad
66
sí, puede hacer `totalTime + = console.timeEnd ('timer') 'y hacerlo para cada temporizador
vsync
637

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);
Owen
fuente
99
Tenga en cuenta que puede sustituir + new Date () por la llamada getTime (): var start = + new Date (); // alerta de hacer cosas ("Tiempo de ejecución:" + (+ nueva Fecha ()) - inicio);
J c
55
Los tiempos no son precisos porque Date no está destinado a esta funcionalidad. Voy a ser audaz aquí y decir que deberías usar el ejemplo de vsync si quieres una sincronización precisa. Aunque solo funciona en Chrome y Firefox ATM.
Ash Blue
99
Cuidado, getMilliseconds () te da la fracción de milisegundos del segundo actual. Si reemplaza getTime () con getMilliseconds (), puede obtener resultados negativos si cruza un segundo.
RickyA
66
La respuesta de vsync es mucho más correcta para los estándares actuales, y el uso de Date () puede dar como resultado que se muestren resultados muy erróneos, especialmente en la plataforma de Windows, donde los resultados pueden redondearse + colocarse en el límite de 15 ms más cercano, lo que resulta en cosas extrañas como Tiempos de 0 ms en pequeños bits de código.
oligofren
29
@AshBlue, deberíamos usar window.performance.now. Ver stackoverflow.com/a/15641427/632951
Pacerier el
405

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.

Pacerier
fuente
3
¡Justo lo que estaba buscando! Quiero poder agregar varias veces juntos, realmente no puedo hacer eso con los tiempos de consola.
Ray
8
Tenga en cuenta que esto todavía no es compatible con Safari: developer.mozilla.org/en-US/docs/Web/API/Performance.now ()
Akos K
2
Uso Firebug Profile y performance.now (), y ambos funcionan bien. Performance.now () confirma mi resultado de Profile.
Vincent Jia
2
No funciona en mi mayor problema, que es IE7 (clientes corporativos). No me importa medir el rendimiento en Chrome, siempre es muy rápido.
Nick
2
Esta es una mejor manera que console.time ().
Sanjeev
52

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í).

NicJ
fuente
1
Excelente y más actual respuesta en mi humilde opinión :) Sería aún mejor con un poco de edición. Yo diría que el tiempo del usuario no es "otra opción" para medir, sino la opción preferida cuando la evaluación comparativa no se realiza en la máquina de desarrollo. Con su polyfill funciona en todos los navegadores. Y esconder los detalles y las repeticiones performance.nowy Datees la razón por la que existe.
hashchange
34

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.

Varvara Kalinina
fuente
Muy buena respuesta! ¡Esto me ayudó mucho!
Combina
18

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

Stefan Mai
fuente
8
Un buen consejo, pero obviamente solo funciona para FF. A menudo queremos comparar las velocidades del navegador ... :-)
PhiLho
3
En el nuevo Firebuq, ocultan estas opciones al menú, usan CTRL + MAYÚS + P o console.profile (); console..profileEnd ()
user956584
44
Chrome admite console.time()y console.timeEnd()también ahora.
julien_c
12
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.

kayz1
fuente
12

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

var hrTime = process.hrtime()
console.log(hrTime[0] * 1000000 + hrTime[1] / 1000)
Achim Koellner
fuente
1
si prefiere convertirlo a ms e-3 en lugar del microsegundo sugerido e-6: hrtime[0] * 1000 + hrtime[1] / 1000000-> sí, ¡prefiero usarlo var hrtimetambién! : P
cregox
11

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');
Alok Deshwal
fuente
8

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.

Levi Roberts
fuente
8

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

usuario1032559
fuente
5

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);
        }
    }
}
Mx.
fuente
5

Te puede ayudar.

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

Wajeeh Aslam
fuente
1
Si bien este fragmento de código puede resolver la pregunta, incluir una explicación realmente ayuda a mejorar la calidad de su publicación. Recuerde que está respondiendo la pregunta para los lectores en el futuro, y que esas personas podrían no conocer los motivos de su sugerencia de código. Por favor, trate de no saturar su código con comentarios explicativos, ¡esto reduce la legibilidad tanto del código como de las explicaciones!
Filnor
5

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.

aljgom
fuente
Esto es exactamente lo que estaba buscando. ¡Gracias!
Andrew Watters
¿Hay alguna manera de hacerlo universal para usar también con funciones asíncronas?
TotalAMD
4

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;

});
Andrew Marin
fuente
3

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

Jonathan Chasteen
fuente
Creo que no necesitas performance.mark('end')en este caso
kofifus
3

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 +.

Rohit Jaiswal
fuente
1
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

jose920405
fuente
1

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'
aljgom
fuente
1

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"
    ]
 }
Yu Huang
fuente
1

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];
    }
};
gombosg
fuente
1

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

toondaey
fuente
0
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
Homam Bahrani
fuente
0

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');
iCPSoni
fuente
0
  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).

bvdb
fuente
-2

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
NlaakALD
fuente
-6

¡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

Mirza Selimovic
fuente
99
No es por el ciclo for. Un bucle for esperará hasta el último bucle hasta que continúe por su código fuente. Las llamadas AJAX son asíncronas. Y también hay otras funciones que se ejecutan de forma asíncrona. Pero un bucle for no se ejecuta asincrónicamente.
Scriptlabs