Come posso confrontare il codice JavaScript? [chiuso]

Esiste un pacchetto che mi aiuta a confrontare il codice JavaScript? Non mi riferisco a Firebug e strumenti simili.

Devo confrontare 2 diverse funzioni JavaScript che ho implementato. Ho molta familiarità con il modulo Benchmark ( Benchmark.pm ) di Perl e sto cercando qualcosa di simile in JavaScript.

L'enfasi sul benchmarking del codice JavaScript ha esagerato? Posso farla franca con il tempismo di una sola esecuzione delle funzioni?

Solo tempo diverse iterazioni di ciascuna funzione. Un'iterazione probabilmente non sarà sufficiente, ma (a seconda della complessità delle tue funzioni) da qualche parte più vicino a 100 o addirittura 1.000 iterazioni dovrebbe fare il lavoro.

Firebug ha anche un profiler se vuoi vedere quali parti della tua funzione lo stanno rallentando.

Modifica: per i futuri lettori, la risposta seguente che consiglia JSPerf dovrebbe essere la risposta corretta. Vorrei eliminare il mio, ma non posso perché è stato selezionato dall'OP. C'è molto di più nel benchmarking oltre all'esecuzione di molte iterazioni e JSPerf si occupa di questo per te.

jsperf.com è il sito di riferimento per testare le prestazioni di JS. Inizia da lì. Se hai bisogno di un framework per eseguire i tuoi test dalla riga di comando o da script, usa Benchmark.js , la libreria su cui è costruito jsperf.com.

Nota: chiunque provi il codice Javascript dovrebbe informarsi sulle insidie ​​dei "microbenchmark" (piccoli test che prendono di mira una funzione o un'operazione specifica, piuttosto che test più complessi basati su modelli di codice del mondo reale). Tali test possono essere utili ma sono soggetti a imprecisioni a causa del funzionamento dei moderni runtime JS. Vale la pena guardare la presentazione di Vyacheslav Egorov sulle prestazioni e il benchmarking per avere un'idea della natura del problema.

Modifica: rimossi i riferimenti al mio lavoro JSLitmus in quanto non è più pertinente o utile.

Basta aggiungere un timer veloce al mix, che qualcuno potrebbe trovare utile:

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 dovrebbe essere inserito in una classe e non usato come globale come ho fatto per esempio sopra. Usarlo sarebbe piuttosto semplice:

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

Solo un modo semplice.

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

Ho usato questa semplice implementazione della risposta @musicfreaks. Non ci sono funzionalità, ma è davvero facile da usare. Questo bench(function(){return 1/2;}, 10000, [], this)calcolerà 1/2 10.000 volte.

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

È davvero difficile scrivere benchmark cross-browser decenti. La semplice temporizzazione di un numero predefinito di iterazioni del codice non è affatto a prova di proiettile .

Come già suggerito da @broofa , controlla jsPerf . Utilizza Benchmark.js dietro le quinte.

se si scrive uno script di benchmark personalizzato, assicurarsi di notare che alcuni browser applicano le manipolazioni dom solo dopo che la funzione in cui sono definiti è terminata. Maggiori dettagli qui http://www.quirksmode.org/blog/archives/2009/08/when_to_read_ou.html

Se hai bisogno di qualcosa di semplice puoi fare in questo modo:

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

Ecco un esempio del codice