Benchmark: Direct call vs bind vs call vs apply spred

Script Preparation code:

let v = -1;

function test(a, b, c) {
  v = a + b + c;
}

setInterval(() => {console.log({ v }); v=-1;}, 5000)

Tests:

direct call
const fn1 = test; fn1(1, 2, 3);
bind
const fn2 = test.bind(this) fn2(2, 3, 4);
call
const fn3 = function (...args) { test.call(this, ...args); }; fn3(3, 4, 5);
apply
const fn4 = function (...args) { test.apply(this, args); }; fn4(4,5,6);
apply arguments
const fn5 = function () { test.apply(this, arguments); }; fn5(7,8,9);
call arguments
const fn3 = function () { test.call(this, ...arguments); }; fn3(10,11,11);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
direct call
bind
call
apply
apply arguments
call arguments

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6.1 Safari/605.1.15

Browser/OS: Safari 17 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
direct call	403114144.0 Ops/sec
bind	58908872.0 Ops/sec
call	29018966.0 Ops/sec
apply	132318536.0 Ops/sec
apply arguments	136577264.0 Ops/sec
call arguments	13246219.0 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The test compares four different ways to call a function: direct call, bind, apply, and two variations of apply (apply with arguments). The goal is to measure which approach is fastest on Firefox 88 running on Windows desktop.

**Options Compared**

1. **Direct Call**: Calling the `test` function directly using its name as an identifier.
2. **Bind**: Binding the `test` function to the global object (`this`) using the `bind` method.
3. **Apply**: Calling the `test` function using the `apply` method, passing the global object and an array of arguments.
4. **Apply with Arguments**: Passing the arguments directly to the `apply` method, without wrapping them in an array.

**Pros and Cons**

* **Direct Call**: Fastest, as it avoids the overhead of function binding or applying. However, it may lead to unexpected behavior if not used carefully.
* **Bind**: A good balance between performance and flexibility. It sets a fixed `this` context for the bound function.
* **Apply**: Can be slower than direct call due to the overhead of setting up the function call. However, it provides more control over the `this` context and allows passing arguments in any order.
* **Apply with Arguments**: May lead to performance issues if not used correctly, as it can create unexpected behavior when dealing with non-argument-capturing functions.

**Libraries and Features**

None of the test cases use external libraries. However, they do utilize some specific JavaScript features:

* **Arrow Functions**: Used in `fn1`, `fn3`, and `fn5`.
* **Spread Syntax**: Used in `fn4` and `fn5`.

These features are part of modern JavaScript syntax and provide concise ways to write functions.

**Other Alternatives**

To optimize the test, other alternatives could be explored:

* Using a different function call method, such as `call`, instead of `apply`.
* Adding more variations, such as using `new` with constructors or exploiting browser quirks.
* Incorporating additional performance metrics, like memory usage or garbage collection frequency.

Keep in mind that introducing new test cases and optimizations might increase the complexity of the benchmark.

Related benchmarks:

Direct call vs bind vs call vs apply spred (version: 0)

Comparing performance of: direct call vs bind vs call vs apply vs apply arguments vs call arguments

Created: 4 years ago by: Guest

Jump to the latest result

direct call

bind

call

apply

apply arguments

call arguments

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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