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

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days 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.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:88.0) Gecko/20100101 Firefox/88.0

Browser/OS: Firefox 88 on Windows

View result in a separate tab

Test name	Executions per second
direct call	704588160.0 Ops/sec
bind	23001230.0 Ops/sec
call	4067710.0 Ops/sec
apply	73994272.0 Ops/sec
apply arguments	120200696.0 Ops/sec
call arguments	3086801.5 Ops/sec

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: 3 years ago by: Guest

Jump to the latest result

direct call

bind

call

apply

apply arguments

call arguments

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):