Comment puis-je comparer le code JavaScript? [fermé]

Existe-t-il un package qui m'aide à évaluer le code JavaScript? Je ne parle pas de Firebug et de tels outils.

J'ai besoin de comparer 2 fonctions JavaScript différentes que j'ai implémentées. Je connais très bien le module Benchmark ( Benchmark.pm ) de Perl et je recherche quelque chose de similaire en JavaScript.

L'accent mis sur l'analyse comparative du code JavaScript est-il allé trop loin? Puis-je me contenter de chronométrer une seule exécution des fonctions?

Il suffit de chronométrer plusieurs itérations de chaque fonction. Une itération ne suffira probablement pas, mais (selon la complexité de vos fonctions) quelque part plus proche de 100 ou même 1000 itérations devrait faire le travail.

Firebug dispose également d'un profileur si vous souhaitez voir quelles parties de votre fonction la ralentissent.

Edit: Pour les futurs lecteurs, la réponse ci-dessous recommandant JSPerf devrait être la bonne réponse. Je supprimerais le mien, mais je ne peux pas car il a été sélectionné par l'OP. L'analyse comparative ne se résume pas à exécuter de nombreuses itérations, et JSPerf s'en charge pour vous.

jsperf.com est le site incontournable pour tester les performances JS. Commencez par là. Si vous avez besoin d'un framework pour exécuter vos propres tests à partir de la ligne de commande ou des scripts, utilisez Benchmark.js , la bibliothèque sur laquelle jsperf.com est construit.

Remarque: toute personne testant du code Javascript doit se renseigner sur les pièges des «microbenchmarks» (petits tests qui ciblent une fonctionnalité ou une opération spécifique, plutôt que des tests plus complexes basés sur des modèles de code réels). Ces tests peuvent être utiles mais sont sujets à des inexactitudes en raison du fonctionnement des environnements d'exécution JS modernes. La présentation de Vyacheslav Egorov sur la performance et l'analyse comparative vaut la peine d'être regardée pour avoir une idée de la nature du ou des problèmes.

Edit: Suppression des références à mon travail JSLitmus car il n'est tout simplement plus pertinent ou utile.

Il suffit d'ajouter un minuteur rapide au mix, ce que quelqu'un peut trouver 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');
        }
    }
};

Idéalement, il serait placé dans une classe et non utilisé comme un global comme je l'ai fait à des fins d'exemple ci-dessus. L'utiliser serait assez simple:

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

Un moyen simple.

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

J'utilise cette implémentation simple de la réponse @musicfreaks. Il n'y a pas de fonctionnalités, mais c'est vraiment facile à utiliser. Cela bench(function(){return 1/2;}, 10000, [], this)calculera 1/2 10000 fois.

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

Il est vraiment difficile d'écrire des benchmarks inter-navigateurs décents. Le simple chronométrage d'un nombre prédéfini d'itérations de votre code n'est pas du tout à toute épreuve .

Comme @broofa l'a déjà suggéré, consultez jsPerf . Il utilise Benchmark.js dans les coulisses.

si vous écrivez un script de référence personnalisé, assurez-vous de noter que certains navigateurs n'appliquent les manipulations dom qu'après la fin de la fonction dans laquelle elles sont définies. Plus de détails ici http://www.quirksmode.org/blog/archives/2009/08/when_to_read_ou.html

Si vous avez besoin de quelque chose de simple, vous pouvez faire comme ceci:

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

Voici un exemple du code