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?
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
performance.now() instead of Date() developer.mozilla.org/en-US/docs/Web/API/Performance/now
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)
