• Benchmark
• Benchmark.Deferred
• Benchmark.Deferred.prototype.resolve
• Benchmark.Event
• Benchmark.Suite
• Benchmark.Suite.prototype.abort
• Benchmark.Suite.prototype.add
• Benchmark.Suite.prototype.clone
• Benchmark.Suite.prototype.filter
• Benchmark.Suite.prototype.reset
• Benchmark.Suite.prototype.run
• Benchmark.filter
• Benchmark.formatNumber
• Benchmark.invoke
• Benchmark.join
• Benchmark.runInContext
• Benchmark.prototype.abort
• Benchmark.prototype.clone
• Benchmark.prototype.compare
• Benchmark.prototype.emit
• Benchmark.prototype.listeners
• Benchmark.prototype.off
• Benchmark.prototype.on
• Benchmark.prototype.reset
• Benchmark.prototype.run
• Benchmark.prototype.toString

• Benchmark.Deferred.prototype.benchmark
• Benchmark.Deferred.prototype.cycles
• Benchmark.Deferred.prototype.elapsed
• Benchmark.Deferred.prototype.timeStamp
• Benchmark.Event.prototype.aborted
• Benchmark.Event.prototype.cancelled
• Benchmark.Event.prototype.currentTarget
• Benchmark.Event.prototype.result
• Benchmark.Event.prototype.target
• Benchmark.Event.prototype.timeStamp
• Benchmark.Event.prototype.type
• Benchmark.Suite.options
• Benchmark.Suite.options.name
• Benchmark.Suite.prototype.aborted
• Benchmark.Suite.prototype.length
• Benchmark.Suite.prototype.running
• Benchmark.options
• Benchmark.options.async
• Benchmark.options.defer
• Benchmark.options.delay
• Benchmark.options.id
• Benchmark.options.initCount
• Benchmark.options.maxTime
• Benchmark.options.minSamples
• Benchmark.options.minTime
• Benchmark.options.name
• Benchmark.options.onAbort
• Benchmark.options.onComplete
• Benchmark.options.onCycle
• Benchmark.options.onError
• Benchmark.options.onReset
• Benchmark.options.onStart
• Benchmark.platform
• Benchmark.support
• Benchmark.support.browser
• Benchmark.version
• Benchmark.prototype.aborted
• Benchmark.prototype.compiled
• Benchmark.prototype.count
• Benchmark.prototype.cycles
• Benchmark.support.decompilation
• Benchmark.prototype.error
• Benchmark.prototype.fn
• Benchmark.prototype.hz
• Benchmark.prototype.running
• Benchmark.prototype.setup
• Benchmark.prototype.stats
• Benchmark.prototype.teardown
• Benchmark.support.timeout
• Benchmark.prototype.times
• Benchmark#stats.deviation
• Benchmark#stats.mean
• Benchmark#stats.moe
• Benchmark#stats.rme
• Benchmark#stats.sample
• Benchmark#stats.sem
• Benchmark#stats.variance
• Benchmark#times.cycle
• Benchmark#times.elapsed
• Benchmark#times.period
• Benchmark#times.timeStamp

The Benchmark constructor.

Note: The Benchmark constructor exposes a handful of lodash methods to make working with arrays, collections, and objects easier. The lodash methods are:
each/forEach, forOwn, has, indexOf, map, and reduce

1. name (string): A name to identify the benchmark.
2. fn (Function|string): The test to benchmark.
3. [options={}] (Object): Options object.

// basic usage (the `new` operator is optional)
var bench = new Benchmark(fn);

// or using a name first
var bench = new Benchmark('foo', fn);

// or with options
var bench = new Benchmark('foo', fn, {

  // displayed by `Benchmark#toString` if `name` is not available
  'id': 'xyz',

  // called when the benchmark starts running
  'onStart': onStart,

  // called after each run cycle
  'onCycle': onCycle,

  // called when aborted
  'onAbort': onAbort,

  // called when a test errors
  'onError': onError,

  // called when reset
  'onReset': onReset,

  // called when the benchmark completes running
  'onComplete': onComplete,

  // compiled/called before the test loop
  'setup': setup,

  // compiled/called after the test loop
  'teardown': teardown
});

// or name and options
var bench = new Benchmark('foo', {

  // a flag to indicate the benchmark is deferred
  'defer': true,

  // benchmark test function
  'fn': function(deferred) {
    // call `Deferred#resolve` when the deferred test is finished
    deferred.resolve();
  }
});

// or options only
var bench = new Benchmark({

  // benchmark name
  'name': 'foo',

  // benchmark test as a string
  'fn': '[1,2,3,4].sort()'
});

// a test's `this` binding is set to the benchmark instance
var bench = new Benchmark('foo', function() {
  'My name is '.concat(this.name); // "My name is foo"
});

The Deferred constructor.

1. clone (Object): The cloned benchmark instance.

Handles cycling/completing the deferred benchmark.

The Event constructor.

1. type (Object|string): The event type.

The Suite constructor.

Note: Each Suite instance has a handful of wrapped lodash methods to make working with Suites easier. The wrapped lodash methods are:
each/forEach, indexOf, map, and reduce

1. name (string): A name to identify the suite.
2. [options={}] (Object): Options object.

// basic usage (the `new` operator is optional)
var suite = new Benchmark.Suite;

// or using a name first
var suite = new Benchmark.Suite('foo');

// or with options
var suite = new Benchmark.Suite('foo', {

  // called when the suite starts running
  'onStart': onStart,

  // called between running benchmarks
  'onCycle': onCycle,

  // called when aborted
  'onAbort': onAbort,

  // called when a test errors
  'onError': onError,

  // called when reset
  'onReset': onReset,

  // called when the suite completes running
  'onComplete': onComplete
});

Aborts all benchmarks in the suite.

(Object): The suite instance.

Adds a test to the benchmark suite.

1. name (string): A name to identify the benchmark.
2. fn (Function|string): The test to benchmark.
3. [options={}] (Object): Options object.

(Object): The suite instance.

// basic usage
suite.add(fn);

// or using a name first
suite.add('foo', fn);

// or with options
suite.add('foo', fn, {
  'onCycle': onCycle,
  'onComplete': onComplete
});

// or name and options
suite.add('foo', {
  'fn': fn,
  'onCycle': onCycle,
  'onComplete': onComplete
});

// or options only
suite.add({
  'name': 'foo',
  'fn': fn,
  'onCycle': onCycle,
  'onComplete': onComplete
});

Creates a new suite with cloned benchmarks.

1. options (Object): Options object to overwrite cloned options.

(Object): The new suite instance.

An Array#filter like method.

1. callback (Function|string): The function/alias called per iteration.

(Object): A new suite of benchmarks that passed callback filter.

Resets all benchmarks in the suite.

(Object): The suite instance.

Runs the suite.

1. [options={}] (Object): Options object.

(Object): The suite instance.

// basic usage
suite.run();

// or with options
suite.run({ 'async': true, 'queued': true });

A generic Array#filter like method.

1. array (Array): The array to iterate over.
2. callback (Function|string): The function/alias called per iteration.

(Array): A new array of values that passed callback filter.

// get odd numbers
Benchmark.filter([1, 2, 3, 4, 5], function(n) {
  return n % 2;
}); // -> [1, 3, 5];

// get fastest benchmarks
Benchmark.filter(benches, 'fastest');

// get slowest benchmarks
Benchmark.filter(benches, 'slowest');

// get benchmarks that completed without erroring
Benchmark.filter(benches, 'successful');

Converts a number to a more readable comma-separated string representation.

1. number (number): The number to convert.

(string): The more readable string representation.

Invokes a method on all items in an array.

1. benches (Array): Array of benchmarks to iterate over.
2. name (Object|string): The name of the method to invoke OR options object.
3. [args] (...*): Arguments to invoke the method with.

(Array): A new array of values returned from each method invoked.

// invoke `reset` on all benchmarks
Benchmark.invoke(benches, 'reset');

// invoke `emit` with arguments
Benchmark.invoke(benches, 'emit', 'complete', listener);

// invoke `run(true)`, treat benchmarks as a queue, and register invoke callbacks
Benchmark.invoke(benches, {

  // invoke the `run` method
  'name': 'run',

  // pass a single argument
  'args': true,

  // treat as queue, removing benchmarks from front of `benches` until empty
  'queued': true,

  // called before any benchmarks have been invoked.
  'onStart': onStart,

  // called between invoking benchmarks
  'onCycle': onCycle,

  // called after all benchmarks have been invoked.
  'onComplete': onComplete
});

Creates a string of joined array values or object key-value pairs.

1. object (Array|Object): The object to operate on.
2. [separator1=','] (string): The separator used between key-value pairs.
3. [separator2=': '] (string): The separator used between keys and values.

(string): The joined result.

Create a new Benchmark function using the given context object.

1. [context=root] (Object): The context object.

(Function): Returns a new Benchmark function.

Aborts the benchmark without recording times.

(Object): The benchmark instance.

Creates a new benchmark using the same test and options.

1. options (Object): Options object to overwrite cloned options.

(Object): The new benchmark instance.

var bizarro = bench.clone({
  'name': 'doppelganger'
});

Determines if a benchmark is faster than another.

1. other (Object): The benchmark to compare.

(number): Returns -1 if slower, 1 if faster, and 0 if indeterminate.

Executes all registered listeners of the specified event type.

1. type (Object|string): The event type or object.
2. [args] (...*): Arguments to invoke the listener with.

(*): Returns the return value of the last listener executed.

Returns an array of event listeners for a given type that can be manipulated to add or remove listeners.

1. type (string): The event type.

(Array): The listeners array.

Unregisters a listener for the specified event type(s), or unregisters all listeners for the specified event type(s), or unregisters all listeners for all event types.

1. [type] (string): The event type.
2. [listener] (Function): The function to unregister.

(Object): The current instance.

// unregister a listener for an event type
bench.off('cycle', listener);

// unregister a listener for multiple event types
bench.off('start cycle', listener);

// unregister all listeners for an event type
bench.off('cycle');

// unregister all listeners for multiple event types
bench.off('start cycle complete');

// unregister all listeners for all event types
bench.off();

Registers a listener for the specified event type(s).

1. type (string): The event type.
2. listener (Function): The function to register.

(Object): The current instance.

// register a listener for an event type
bench.on('cycle', listener);

// register a listener for multiple event types
bench.on('start cycle', listener);

Reset properties and abort if running.

(Object): The benchmark instance.

Runs the benchmark.

1. [options={}] (Object): Options object.

(Object): The benchmark instance.

// basic usage
bench.run();

// or with options
bench.run({ 'async': true });

Displays relevant benchmark information when coerced to a string.

(string): A string representation of the benchmark instance.

The deferred benchmark instance.

The number of deferred cycles performed while benchmarking.

The time taken to complete the deferred benchmark (secs).

A timestamp of when the deferred benchmark started (ms).

A flag to indicate if the emitters listener iteration is aborted.

A flag to indicate if the default action is cancelled.

The object whose listeners are currently being processed.

The return value of the last executed listener.

The object to which the event was originally emitted.

A timestamp of when the event was created (ms).

The event type.

The default options copied by suite instances.

The name of the suite.

A flag to indicate if the suite is aborted.

The number of benchmarks in the suite.

A flag to indicate if the suite is running.

The default options copied by benchmark instances.

A flag to indicate that benchmark cycles will execute asynchronously by default.

A flag to indicate that the benchmark clock is deferred.

The delay between test cycles (secs).

Displayed by Benchmark#toString when a name is not available (auto-generated if absent).

The default number of times to execute a test on a benchmark's first cycle.

The maximum time a benchmark is allowed to run before finishing (secs).

Note: Cycle delays aren't counted toward the maximum time.

The minimum sample size required to perform statistical analysis.

The time needed to reduce the percent uncertainty of measurement to 1% (secs).

The name of the benchmark.

An event listener called when the benchmark is aborted.

An event listener called when the benchmark completes running.

An event listener called after each run cycle.

An event listener called when a test errors.

An event listener called when the benchmark is reset.

An event listener called when the benchmark starts running.

Platform object with properties describing things like browser name, version, and operating system. See platform.js.

An object used to flag environments/features.

Detect if running in a browser environment.

The semantic version number.

A flag to indicate if the benchmark is aborted.

The compiled test function.

The number of times a test was executed.

The number of cycles performed while benchmarking.

Detect if function decompilation is support.

The error object if the test failed.

The test to benchmark.

The number of executions per second.

A flag to indicate if the benchmark is running.

Compiled into the test and executed immediately before the test loop.

// basic usage
var bench = Benchmark({
  'setup': function() {
    var c = this.count,
        element = document.getElementById('container');
    while (c--) {
      element.appendChild(document.createElement('div'));
    }
  },
  'fn': function() {
    element.removeChild(element.lastChild);
  }
});

// compiles to something like:
var c = this.count,
    element = document.getElementById('container');
while (c--) {
  element.appendChild(document.createElement('div'));
}
var start = new Date;
while (count--) {
  element.removeChild(element.lastChild);
}
var end = new Date - start;

// or using strings
var bench = Benchmark({
  'setup': '\
    var a = 0;\n\
    (function() {\n\
      (function() {\n\
        (function() {',
  'fn': 'a += 1;',
  'teardown': '\
         }())\n\
       }())\n\
     }())'
});

// compiles to something like:
var a = 0;
(function() {
  (function() {
    (function() {
      var start = new Date;
      while (count--) {
        a += 1;
      }
      var end = new Date - start;
    }())
  }())
}())

An object of stats including mean, margin or error, and standard deviation.

Compiled into the test and executed immediately after the test loop.

Detect if the Timers API exists.

An object of timing data including cycle, elapsed, period, start, and stop.

The sample standard deviation.

The sample arithmetic mean (secs).

The margin of error.

The relative margin of error (expressed as a percentage of the mean).

The array of sampled periods.

The standard error of the mean.

The sample variance.

The time taken to complete the last cycle (secs).

The time taken to complete the benchmark (secs).

The time taken to execute the test once (secs).

A timestamp of when the benchmark started (ms).