How can I benchmark JavaScript code?

Is there a package that helps me benchmark JavaScript code? I'm not referring to Firebug and such tools.

I need to compare 2 different JavaScript functions that I have implemented. I'm very familiar with Perl's Benchmark (Benchmark.pm) module and I'm looking for something similar in JavaScript.

Has the emphasis on benchmarking JavaScript code gone overboard? Can I get away with timing just one run of the functions?

jsperf.com is the go-to site for testing JS performance. Start there. If you need a framework for running your own tests from the command line or scripts use Benchmark.js, the library upon which jsperf.com is built.

Note: Anyone testing Javascript code should educate themselves on the pitfalls of "microbenchmarks" (small tests that target a specific feature or operation, rather than more complex tests based on real-world code patterns). Such tests can be useful but are prone to inaccuracy due to how modern JS runtimes operate. Vyacheslav Egorov's presentation on performance and benchmarking is worth watching to get a feel for the nature of the problem(s).

Edit: Removed references to my JSLitmus work as it's just no longer relevant or useful.

Just simple way.

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

Just adding a quick timer to the mix, which someone may find useful:

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

Ideally it would be placed in a class, and not used as a global like I did for example purposes above. Using it would be pretty simple:

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

Just time several iterations of each function. One iteration probably won't be enough, but (depending on how complex your functions are) somewhere closer to 100 or even 1,000 iterations should do the job.

Firebug also has a profiler if you want to see which parts of your function are slowing it down.

Edit: To future readers, the below answer recommending JSPerf should be the correct answer. I would delete mine, but I can't because it has been selected by the OP. There is much more to benchmarking than just running many iterations, and JSPerf takes care of that for you.

I have been using this simple implementation of @musicfreaks answer. There are no features, but it is really easy to use. This bench(function(){return 1/2;}, 10000, [], this) will calculate 1/2 10,000 times.

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

It’s really hard to write decent cross-browser benchmarks. Simply timing a pre-defined number of iterations of your code is not bulletproof at all.

As @broofa already suggested, check out jsPerf. It uses Benchmark.js behind the scenes.

if writing a custom benchmark script be sure to note that some browsers apply dom manipulations only after function in which they are defined is ended. More details here http://www.quirksmode.org/blog/archives/2009/08/when_to_read_ou.html

If you need something simple you can do like this:

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

Here is an example of the code