Benchmark: Explicit call vs apply

Script Preparation code:

function wrapExplicit(fn) {
  return function(a1, a2, a3) {
    return fn.call(this, this, a1, a2, a3)
  }
}

function wrapApply(fn) {
  return function() {
    var args = [this]
	for (let i = 0, len = arguments.length; i < len; i++) {
      args[i + 1] = arguments[i]
  	}
  	return fn.apply(this, args)
  }
}

function wrapApplyWithArguments(fn) {
  return function() {
  	return fn.apply(this, [this].concat(arguments))
  }
}

function fn(thisArg, a1, a2, a3) {
  thisArg.result = a1 + a2 + a3
}

var explicitCall = { fn: wrapExplicit(fn) }
var applyCall = { fn: wrapApply(fn) }
var applyWithArgumentsCall = { fn: wrapApplyWithArguments(fn) }

Tests:

Explicit call
explicitCall.fn(Math.random(), Math.random(), Math.random())
Apply call
applyCall.fn(Math.random(), Math.random(), Math.random())
Apply with arguments call
applyWithArgumentsCall.fn(Math.random(), Math.random(), Math.random())

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Explicit call
Apply call
Apply with arguments call

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0

Browser/OS: Firefox 150 on Linux

View result in a separate tab

Test name	Executions per second
Explicit call	124464208.0 Ops/sec
Apply call	15801184.0 Ops/sec
Apply with arguments call	2614423.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition**

The provided JSON represents a benchmark that tests three different approaches to handling small arity function calls in JavaScript: explicit calls, apply calls, and apply with arguments calls.

In this context, "arity" refers to the number of formal parameters a function takes. In the given benchmark, the `fn` function takes 3 arguments (`a1`, `a2`, and `a3`). The goal is to compare the performance of three different wrappers around this function:

1. **Explicit Call**: This approach uses a separate wrapper function that explicitly calls the original `fn` function with the correct number of arguments.
2. **Apply Call**: This approach uses the built-in `apply()` method to call the original `fn` function with the correct number of arguments, passing the first argument as the context (`this`) and subsequent arguments in an array.
3. **Apply with Arguments Call**: This approach uses a wrapper function that combines the apply() method with the spread operator (`...`) to pass all arguments in an array.

**Options Comparison**

The three approaches have different trade-offs:

*   **Explicit Calls**: Pros:
    *   Explicit and easy to understand
    *   Can be optimized for specific use cases
*   Cons:
    *   May introduce additional overhead due to the wrapper function
*   **Apply Calls**: Pros:
    *   Native JavaScript method with built-in performance optimizations
    *   Fewer lines of code compared to explicit calls
*   Cons:
    *   Less intuitive than explicit calls
    *   May require more memory allocation for the array of arguments
*   **Apply with Arguments Calls**: Pros:
    *   Combines the benefits of apply and explicit calls
    *   Reduces code duplication

Cons:

*   Less optimized compared to native apply() method

**Library Considerations**

None of the provided wrappers use external libraries. However, if we were to extend this benchmark to include more complex functions or utility methods from a library like Lodash, we might see differences in performance.

**Special JS Features/Syntax**

The benchmark makes use of ES6 features:

*   Arrow functions (`wrapExplicit`, `wrapApply`, and `wrapApplyWithArguments`)
*   Spread operator (`...`)

While not essential to the basic understanding of the benchmark, it's worth noting that these features are relatively recent additions to the JavaScript language.

**Alternatives**

If you were to rewrite this benchmark using a different approach or technique, some alternatives might include:

*   **Using native functions**: Instead of wrapping the original function, consider using native functions like `fn.bind()` or `fncurry()` from libraries like Lodash.
*   **Type-based optimization**: Consider adding type annotations to optimize the code for specific use cases or environments.
*   **Other benchmarking techniques**: Experiment with different benchmarking frameworks or methodologies, such as using WebAssembly or V8's `JIT` compiler.

In conclusion, this benchmark provides a clear comparison of three approaches to handling small arity function calls in JavaScript. Understanding the trade-offs and benefits of each approach can help developers optimize their code for specific use cases and performance requirements.

Related benchmarks:

Explicit call vs apply (version: 5)

See if there is a real benefit to handle small arity function calls with explicit calls or if apply is sufficient.

Comparing performance of: Explicit call vs Apply call vs Apply with arguments call

Created: 9 years ago by: Registered User

Jump to the latest result

Explicit call

Apply call

Apply with arguments call

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):