Como medir o tempo gasto por uma função para executar

Preciso obter tempo de execução em milissegundos.

Eu originalmente fiz essa pergunta em 2008. A resposta aceita era usar o novo Date (). GetTime () No entanto, todos podemos concordar agora que o uso da API performance.now () padrão é mais apropriado. Portanto, estou mudando a resposta aceita para 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: é necessário importar operformance classe

Usando console.time :(não padrão)( padrão de vida )

console.time('someFunction')

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

console.timeEnd('someFunction')

Nota :
A sequência que está sendo passada para osmétodostime()etimeEnd()deve corresponder
(para que o cronômetro termine conforme o esperado).

console.time() documentações:

1. Documentação do NodeJS referente a
2. Documentação MDN (lado do cliente)

use new Date (). getTime ()

O método getTime () retorna o número de milissegundos desde a meia-noite de 1 de janeiro 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);

Não use Date (). Leia abaixo.

Useperformance.now() :

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

Funciona em:

• IE 10 ++

• FireFox 15 ++

• Chrome 24 ++

• Safari 8 ++

• Opera 15 ++

• Android 4.4 ++

• etc etc

console.timepode ser viável para você , mas é não-padrão § :

Esse recurso não é padrão e não está em uma faixa de padrões. Não o use em sites de produção voltados para a Web: ele não funcionará para todos os usuários. Também pode haver grandes incompatibilidades entre implementações e o comportamento pode mudar no futuro.

Além do suporte ao navegador, performance.nowparece ter o potencial de fornecer intervalos mais precisos, pois parece ser a versão básica do console.time.

<rant> Além disso, NUNCA use Datepara nada porque é afetado por alterações na "hora do sistema". O que significa que irá obter resultados inválidos -como "sincronismo negativo" - quando o usuário não tem um tempo de sistema preciso:

Em outubro de 2014, o relógio do sistema deu errado e adivinhem ... Abri o Gmail e vi todos os emails do meu dia "enviados há 0 minutos ". E eu pensei que o Gmail deveria ser construído por engenheiros de classe mundial do Google .......

(Defina o relógio do sistema para um ano atrás e vá para o Gmail para que todos possamos dar boas risadas. Talvez um dia tenhamos um Hall of Shame for JS Date.)

A now()função da planilha do Google também sofre com esse problema.

A única vez que você usará será Datequando quiser mostrar ao usuário a hora do relógio do sistema. Não quando você deseja obter o tempo ou a medida nada.

Se você precisar obter tempo de execução da função em sua máquina de desenvolvimento local , poderá usar as ferramentas de criação de perfil do navegador ou comandos do console como console.time()e console.timeEnd().

Todos os navegadores modernos têm perfis de JavaScript incorporados. Esses criadores de perfil devem fornecer as medidas mais precisas, pois você não precisa modificar o código existente, o que pode afetar o tempo de execução da função.

Para criar um perfil do seu JavaScript:

• No Chrome , pressione F12 e selecione a guia Perfis e , em seguida, Coletar perfil de CPU JavaScript .
• No Firefox , instale / abra o Firebug e clique no botão Perfil .
• No IE 9+ , pressione F12 , clique em Script ou Profiler (dependendo da sua versão do IE).

Como alternativa, na sua máquina de desenvolvimento , você pode adicionar instrumentação ao seu código com console.time()e console.timeEnd(). Essas funções, suportadas no Firefox11 +, Chrome2 + e IE11 +, relatam os temporizadores pelos quais você inicia / para console.time(). time()usa um nome de timer definido pelo usuário como argumento e, em timeEnd()seguida, relata o tempo de execução desde o início do timer:

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

Observe que apenas o Firefox retorna o tempo decorrido na timeEnd()chamada. Os outros navegadores simplesmente informam o resultado ao console do desenvolvedor: o valor de retorno de timeEnd()é indefinido.

Se você deseja obter tempo de execução de funções em estado selvagem , precisará instrumentar seu código. Você tem algumas opções. Você pode simplesmente salvar os horários de início e término consultando new Date().getTime():

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

No entanto, o Dateobjeto tem apenas uma resolução de milissegundos e será afetado pelas alterações no relógio do sistema do sistema operacional. Nos navegadores modernos, há uma opção melhor.

A melhor opção é usar o tempo de alta resolução , também conhecido como window.performance.now(). now()é melhor que o tradicional Date.getTime()de duas maneiras importantes:

1. now()é um duplo com resolução de submilissegundo que representa o número de milissegundos desde o início da navegação da página. Retorna o número de microssegundos no fracionário (por exemplo, um valor de 1000.123 é 1 segundo e 123 microssegundos).

2. now()está aumentando monotonicamente. Isto é importante porque Date.getTime()pode possivelmente saltar para a frente ou mesmo para trás em chamadas subseqüentes. Notavelmente, se a hora do sistema do sistema operacional for atualizada (por exemplo, sincronização do relógio atômico), ela Date.getTime()também será atualizada. now()é garantido que sempre aumenta monotonicamente, portanto, não é afetado pela hora do sistema do sistema operacional - sempre será a hora do relógio de parede (supondo que seu relógio de parede não seja atômico ...).

now()pode ser usado em quase todos os lugares que new Date().getTime(), + new Dateandt Date.now()são. A exceção é que, Datee os now()tempos não se misturam, com Datebase na época unix (o número de milissegundos desde 1970), enquanto now()é o número de milissegundos desde que a navegação da página foi iniciada (portanto, será muito menor que Date).

Aqui está um exemplo de como usar now():

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

now()é suportado no Chrome estável, Firefox 15+ e IE10. Existem também vários polyfills disponíveis.

Uma outra opção para medir o tempo de execução no ambiente é o UserTiming . UserTiming se comporta de forma semelhante a console.time()e console.timeEnd(), mas utiliza a mesma alta resolução Timestamp que now()usos (de modo a obter um sub-milissegundo monótona crescente relógio), e salva os timestamps e durações à PerformanceTimeline .

UserTiming possui os conceitos de marcas (timestamps) e medidas (durações). Você pode definir quantos quiser e eles são expostos no PerformanceTimeline .

Para salvar um carimbo de data e hora, você liga mark(startMarkName). Para obter a duração desde a sua primeira marca, basta ligar measure(measurename, startMarkname). A duração é salva no PerformanceTimeline ao lado de suas marcas.

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

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

O UserTiming está disponível no IE10 + e Chrome25 +. Há também um polyfill disponível (que eu escrevi).

Para obter valores precisos, você deve usar a interface Performance . É suportado em versões modernas do Firefox, Chrome, Opera e IE. Aqui está um exemplo de como ele pode ser usado:

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()não são bons para medir o tempo de execução preciso. Você pode usá-los se a estimativa aproximada rápida for boa para você. Por estimativa aproximada, quero dizer que você pode obter uma troca de 15 a 60 ms em tempo real.

Confira este post brilhante sobre como medir o tempo de execução em JavaScript. O autor também fornece alguns links sobre a precisão do tempo do JavaScript, vale a pena ler.

Use o Firebug, ative o Console e o Javascript. Clique em perfil. Recarregar. Clique em perfil novamente. Veja o relatório.

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

Referência

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

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

stopwatch.stop();

stopwatch.printElapsed();

Resultado

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 () é opcional - basta passar false para a função do construtor StopWatch.

process.hrtime () está disponível no Node.js - retorna um valor em nanossegundos

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

você pode usar adicionar operador também aqui

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

Para estender o código do vsync para ter a capacidade de retornar o timeEnd como um valor no NodeJS, use este pequeno pedaço 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;
};

Agora use o código da seguinte maneira:

console.time('someFunction timer');

someFunction();

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

Isso lhe dá mais possibilidades. Você pode armazenar o tempo de execução a ser usado para mais propósitos, como usá-lo em equações ou armazenado em um banco de dados, enviado a um cliente remoto por websockets, servido em uma página da web etc.

É possível usar apenas uma variável:

var timer = -performance.now();

// Do something

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

timer/1000 - converter milissegundos em segundos

.toFixed(5) - para cortar dígitos extras

Desde console.timee performance.nownão é suportado em alguns navegadores principais (ie IE10), criei um utilitário fino que utiliza os melhores métodos disponíveis. No entanto, falta tratamento de erros para usos falsos (chamarEnd() um timer não inicializado).

Use-o e melhore-o como quiser.

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

Isso pode ajudá-lo.

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

Aqui está um decorador para funções de temporização

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' 

Se você estiver usando funções assíncronas, você pode fazer timedasync e adicionar um awaitantes de f (... args), e isso deve funcionar para eles. Fica mais complicado se você deseja que um decorador lide com as funções de sincronização e assíncrona.

Obrigado, Achim Koellner, expandirá sua resposta um pouco:

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

Observe que você não deve fazer nada além do que deseja medir (por exemplo, console.log também levará tempo para executar e afetará os testes de desempenho).

Observe que, para medir o tempo de execução das funções assíncronas, você deve inserir var timeInMilliseconds = process.hrtime(t0)[1]/1000000;dentro do retorno de chamada. Por exemplo,

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

});

Alguns meses atrás, montei minha própria rotina que cronometra uma função usando Date.now () - embora na época o método aceito parecesse performance.now () - porque o objeto de desempenho ainda não estava disponível (construído -in) na versão estável do Node.js.

Hoje eu estava pesquisando um pouco mais e encontrei outro método para cronometrar. Como também descobri como usar isso no código Node.js., pensei em compartilhá-lo aqui.

O seguinte é combinado a partir dos exemplos fornecidos pelo w3c e pelo 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:

Se você pretende usar o performanceobjeto em um aplicativo Node.js., você deve incluir o seguinte requisito: const { performance } = require('perf_hooks')

existem várias maneiras de atingir esse 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 é a maneira mais eficiente: usar performance.now () , por exemplo

   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 + (adicionar operador) 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);

Aqui está o que acontece quando você aplica o operador unary plus a uma instância de Data: Obtenha o valor da instância de Data em questão Converta-o em um Número

NOTA: getTime()oferece melhor desempenho que o operador unário +.

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 a string.

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

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

Se você deseja medir o tempo entre várias coisas que não estão aninhadas, use:

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

É semelhante ao console.time (), mas é mais fácil de usar se você não precisar acompanhar os cronômetros anteriores.

Se você gosta da cor azul de console.time (), pode usar esta linha

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'

No meu caso, eu prefiro usar @ grammar suger e compilá-lo com babel.
O problema desse método é que a função precisa estar dentro do objeto.

Código JS de amostra

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 com ciclos cumulativos

Funciona com servidor e cliente (Nó ou DOM), usa o Performance API. Bom quando você tem muitos ciclos pequenos, por exemplo, em uma função chamada 1000 vezes que processa 1000 objetos de dados, mas você deseja ver como cada operação nesta função se soma ao total.

Portanto, este usa um temporizador global (singleton) do módulo. O mesmo que um padrão de classe singleton, apenas um pouco mais simples de usar, mas você precisa colocá-lo em um stopwatch.jsarquivo, por exemplo, separado .

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

A melhor maneira seria usar o performance hooksmódulo. Embora instável, você pode markáreas específicas do seu código e measureas durationá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);

Experimente 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

Com desempenho

NodeJs: é necessário importar a classe de desempenho

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 o timer, useconsole.time("myTimer");
2. Opcional: Para imprimir o tempo decorrido, use console.timeLog("myTimer");
3. Por fim, para parar o cronômetro e imprimir a hora final:console.timeEnd("myTimer");

Você pode ler mais sobre isso em MDN e na documentação Node.js .

Disponível no Chrome, Firefox, Opera e NodeJS. (não no Edge ou no Internet Explorer).

Conforme indicado anteriormente, verifique e use o temporizador incorporado. Mas se você quiser ou precisar escrever seu próprio, aqui estão meus dois 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}}}();

A compilação foi um sucesso!

• Tamanho original: 219 bytes compactados (405 bytes não compactados)
• Tamanho compilado: 109 bytes compactados (187 bytes não compactados)
• Economizou 50,23% no tamanho compactado com gzip (53,83% sem gzip

A resposta aceita está errada !

Como o JavaScript é assíncrono, os valores da variável final da resposta aceita estarão incorretos.

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

A execução do for pode ser muito rápida, portanto você não pode ver que o resultado está errado. Você pode testá-lo com um código fazendo uma solicitação:

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

Portanto, o alerta será solicitado rapidamente, mas no console você verá que as solicitações do ajax continuam.

Aqui está como você deve fazê-lo: https://developer.mozilla.org/en-US/docs/Web/API/Performance.now