Como posso comparar o código JavaScript? [fechadas]

Existe um pacote que me ajuda a comparar o código JavaScript? Não estou me referindo ao Firebug e essas ferramentas.

Preciso comparar 2 funções JavaScript diferentes que implementei. Estou muito familiarizado com o módulo Benchmark ( Benchmark.pm ) do Perl e estou procurando algo semelhante em JavaScript.

A ênfase no benchmarking do código JavaScript extrapolou os limites? Posso me safar de cronometrar apenas uma execução das funções?

Tempo várias iterações de cada função. Uma iteração provavelmente não será suficiente, mas (dependendo de quão complexas são as suas funções) algo próximo a 100 ou mesmo 1.000 iterações deve fazer o trabalho.

O Firebug também tem um criador de perfil se você quiser ver quais partes de sua função estão tornando-o mais lento.

Edit: Para futuros leitores, a resposta abaixo recomendando JSPerf deve ser a resposta correta. Gostaria de deletar o meu, mas não posso porque foi selecionado pelo OP. O benchmarking envolve muito mais do que apenas executar várias iterações, e o JSPerf cuida disso para você.

jsperf.com é o site para teste de desempenho de JS. Comece por aí. Se você precisa de uma estrutura para executar seus próprios testes a partir da linha de comando ou scripts, use Benchmark.js , a biblioteca na qual jsperf.com foi construído.

Observação: qualquer pessoa que esteja testando o código Javascript deve se educar sobre as armadilhas dos "microbenchmarks" (pequenos testes que visam um recurso ou operação específica, em vez de testes mais complexos baseados em padrões de código do mundo real). Esses testes podem ser úteis, mas estão sujeitos a imprecisões devido à forma como os tempos de execução JS modernos operam. Vale a pena assistir à apresentação de Vyacheslav Egorov sobre desempenho e benchmarking para ter uma ideia da natureza do (s) problema (s).

Edit: Removidas referências ao meu trabalho JSLitmus, pois não é mais relevante ou útil.

Basta adicionar um temporizador rápido à mistura, que alguém pode achar útil:

var timer = function(name) {
    var start = new Date();
    return {
        stop: function() {
            var end  = new Date();
            var time = end.getTime() - start.getTime();
            console.log('Timer:', name, 'finished in', time, 'ms');
        }
    }
};

Idealmente, ele seria colocado em uma classe e não usado como um global como fiz para os exemplos acima. Usar seria muito simples:

var t = timer('Some label');
// code to benchmark
t.stop(); // prints the time elapsed to the js console

Maneira simples.

console.time('test');
console.timeEnd('test');

Tenho usado esta implementação simples da resposta @musicfreaks. Não há recursos, mas é muito fácil de usar. Isso bench(function(){return 1/2;}, 10000, [], this)calculará 1/2 10.000 vezes.

/**
 * Figure out how long it takes for a method to execute.
 * 
 * @param {Function} method to test 
 * @param {number} iterations number of executions.
 * @param {Array} args to pass in. 
 * @param {T} context the context to call the method in.
 * @return {number} the time it took, in milliseconds to execute.
 */
var bench = function (method, iterations, args, context) {

    var time = 0;
    var timer = function (action) {
        var d = Date.now();
        if (time < 1 || action === 'start') {
            time = d;
            return 0;
        } else if (action === 'stop') {
            var t = d - time;
            time = 0;    
            return t;
        } else {
            return d - time;    
        }
    };

    var result = [];
    var i = 0;
    timer('start');
    while (i < iterations) {
        result.push(method.apply(context, args));
        i++;
    }

    var execTime = timer('stop');

    if ( typeof console === "object") {
        console.log("Mean execution time was: ", execTime / iterations);
        console.log("Sum execution time was: ", execTime);
        console.log("Result of the method call was:", result[0]);
    }

    return execTime;  
};

É realmente difícil escrever benchmarks decentes entre navegadores. Simplesmente cronometrar um número predefinido de iterações de seu código não é à prova de balas .

Como @broofa já sugeriu, verifique jsPerf . Ele usa Benchmark.js nos bastidores.

se estiver escrevendo um script de benchmark personalizado, certifique-se de observar que alguns navegadores aplicam manipulações de dom somente após o término da função em que foram definidos. Mais detalhes aqui http://www.quirksmode.org/blog/archives/2009/08/when_to_read_ou.html

Se você precisa de algo simples, pode fazer assim:

'use strict'
console.clear()

const powerOf = x => y => Math.pow(x, y)
const powerOfThree = powerOf(3)

function performanceCalc(fn, ...params) {
    const start = +new Date()
    const result = fn(...params)
    const end = +new Date()

    console.log(`Result: ${result}. Execution Time: ${end - start} ms`)
}

performanceCalc(powerOfThree, 2)

Aqui está um exemplo do código