Benchmark: Explicit call vs apply

Script Preparation code:

function wrap(fn) {
  // fast path if arity < 4, slow path if not
  switch (fn.length) {
    case 0:
      return function() {
        return fn.call(this)
      }
    case 1:
      return function() {
        return fn.call(this, this)
      }
    case 2:
      return function(a1) {
        return fn.call(this, this, a1)
      }
    case 3:
      return function(a1, a2) {
        return fn.call(this, this, a1, a2)
      }
    case 4:
      return function(a1, a2, a3) {
        return fn.call(this, this, a1, a2, a3)
      }
    default:
      return function() {
        const args = [this]
        for (let i = 0, len = arguments.length; i < len; i++) {
          args[i + 1] = arguments[i]
        }
        return fn.apply(this, args)
      }
  }
}

var counter = 0

var f0 = wrap(function() { return counter++ })
var f1 = wrap(function(a) { return (counter += a) })
var f2 = wrap(function(a, b) { return (counter += (a + b)) })
var f3 = wrap(function(a, b, c) { return (counter += (a + b + c)) })
var f4 = wrap(function(a, b, c, d) { return (counter += (a + b + c + d)) })
var f5 = wrap(function(a, b, c, d, e) { return (counter += (a + b + c + d + e)) })

​x
 
function wrap(fn) {  // fast path if arity < 4, slow path if not  switch (fn.length) {    case 0:      return function() {        return fn.call(this)      }    case 1:      return function() {        return fn.call(this, this)      }    case 2:      return function(a1) {        return fn.call(this, this, a1)      }    case 3:      return function(a1, a2) {        return fn.call(this, this, a1, a2)      }    case 4:      return function(a1, a2, a3) {        return fn.call(this, this, a1, a2, a3)      }    default:      return function() {        const args = [this]        for (let i = 0, len = arguments.length; i < len; i++) {          args[i + 1] = arguments[i]        }        return fn.apply(this, args)      }  }}​var counter = 0​var f0 = wrap(function() { return counter++ })var f1 = wrap(function(a) { return (counter += a) })var f2 = wrap(function(a, b) { return (counter += (a + b)) })var f3 = wrap(function(a, b, c) { return (counter += (a + b + c)) })var f4 = wrap(function(a, b, c, d) { return (counter += (a + b + c + d)) })var f5 = wrap(function(a, b, c, d, e) { return (counter += (a + b + c + d + e)) })

Tests:

With 0 parameter
f0()
f0()
With 1 parameter
f1(Date.now)
f1(Date.now)
With 2 parameters
f2(Date.now, Date.now + 1)
f2(Date.now, Date.now + 1)
With 3 parameters
f3(Date.now, Date.now + 1, Date.now + 2)
f3(Date.now, Date.now + 1, Date.now + 2)
With 4 parameters
f4(Date.now, Date.now + 1, Date.now + 2, Date.now + 3)
f4(Date.now, Date.now + 1, Date.now + 2, Date.now + 3)
With 5 parameters
f5(Date.now, Date.now + 1, Date.now + 2, Date.now + 3, Date.now + 4)
f5(Date.now, Date.now + 1, Date.now + 2, Date.now + 3, Date.now + 4)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
With 0 parameter
With 1 parameter
With 2 parameters
With 3 parameters
With 4 parameters
With 5 parameters

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 8 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36

Browser/OS: Chrome 52 on Mac OS X 10.11.6

View result in a separate tab

Test name	Executions per second
With 0 parameter	2810095.5 Ops/sec
With 1 parameter	445385.5 Ops/sec
With 2 parameters	216158.5 Ops/sec
With 3 parameters	146745.9 Ops/sec
With 4 parameters	31633.5 Ops/sec
With 5 parameters	2730.4 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

Let's break down what's being tested in the provided JSON.

Benchmark Definition

The benchmark measures the performance of JavaScript functions with different numbers of arguments using two approaches:

wrap function: This is a custom wrapper function created by MeasureThat.net to handle the creation and execution of the benchmarked functions.
Built-in apply() method or direct function invocation (fn(), f0(), etc.).

Options being compared

The benchmark compares the performance of:

Direct function invocation (fn())
Using the apply() method (fn.apply(this))
The custom wrap function with different numbers of arguments (from 0 to 5)

Pros and Cons of each approach:

Direct function invocation (fn())
- Pros:
  - Simple and efficient
  - Fast execution
- Cons:
  - May not work correctly for functions with a variable number of arguments
Using the apply() method (fn.apply(this))
- Pros:
  - Flexible and can handle functions with a variable number of arguments
  - Can be used to call functions in different contexts
- Cons:
  - May have performance overhead due to the additional indirection
Custom wrap function
- Pros:
  - Provides a flexible way to handle functions with a variable number of arguments
  - Allows for fine-grained control over function execution and argument handling
- Cons:
  - More complex implementation
  - May have performance overhead due to the additional indirection

Special considerations

The benchmark uses some special JavaScript features, such as:

Date.now to create a timestamp value that can be passed as an argument
The with statement is not used in this case, but it's worth noting that it can be used to create a new scope and execute code within it.

Other alternatives

If you're interested in alternative approaches for handling functions with a variable number of arguments, some options include:

Using a library like Lodash or Ramda to provide utility functions for working with functions and arrays
Implementing your own function with a variable number of arguments using techniques like currying or function composition
Using JavaScript generators or async/await syntax to create asynchronous functions that can handle a variable number of arguments.

Keep in mind that the performance characteristics of each approach may vary depending on the specific use case and requirements.

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON.

**Benchmark Definition**

The benchmark measures the performance of JavaScript functions with different numbers of arguments using two approaches:

1. `wrap` function: This is a custom wrapper function created by MeasureThat.net to handle the creation and execution of the benchmarked functions.
2. Built-in `apply()` method or direct function invocation (`fn()`, `f0()`, etc.).

**Options being compared**

The benchmark compares the performance of:

* Direct function invocation (`fn()`)
* Using the `apply()` method (`fn.apply(this)`)
* The custom `wrap` function with different numbers of arguments (from 0 to 5)

**Pros and Cons of each approach:**

1. **Direct function invocation (`fn()`)**
	* Pros:
		+ Simple and efficient
		+ Fast execution
	* Cons:
		+ May not work correctly for functions with a variable number of arguments
2. **Using the `apply()` method (`fn.apply(this)`)**
	* Pros:
		+ Flexible and can handle functions with a variable number of arguments
		+ Can be used to call functions in different contexts
	* Cons:
		+ May have performance overhead due to the additional indirection
3. **Custom `wrap` function**
	* Pros:
		+ Provides a flexible way to handle functions with a variable number of arguments
		+ Allows for fine-grained control over function execution and argument handling
	* Cons:
		+ More complex implementation
		+ May have performance overhead due to the additional indirection

**Special considerations**

The benchmark uses some special JavaScript features, such as:

* `Date.now` to create a timestamp value that can be passed as an argument
* The `with` statement is not used in this case, but it's worth noting that it can be used to create a new scope and execute code within it.

**Other alternatives**

If you're interested in alternative approaches for handling functions with a variable number of arguments, some options include:

* Using a library like Lodash or Ramda to provide utility functions for working with functions and arrays
* Implementing your own function with a variable number of arguments using techniques like currying or function composition
* Using JavaScript generators or async/await syntax to create asynchronous functions that can handle a variable number of arguments.

Keep in mind that the performance characteristics of each approach may vary depending on the specific use case and requirements.

Related benchmarks:

Explicit call vs apply (version: 0)

Comparing performance of: With 0 parameter vs With 1 parameter vs With 2 parameters vs With 3 parameters vs With 4 parameters vs With 5 parameters

Created: 8 years ago by: Guest

Jump to the latest result

With 0 parameter

With 1 parameter

With 2 parameters

With 3 parameters

With 4 parameters

With 5 parameters

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):