Benchmark: Direct call vs bind vs call vs apply

Script Preparation code:

function test(msg) {
  var d = msg;
}

Tests:

direct call
test("Hello");
bind
test.bind(null, "Hello")();
call
test.call(null, "Hello");
apply
test.apply(null, ["Hello"]);

Historical Performance Data aggregated from 121 community runs

Desktop Results:

Chrome 86 runs

direct call

26.8M/s

call

24.0M/s

apply

23.9M/s

bind

23.7M/s

Fastest: direct call (1.1x faster)

View exact numbers

✓ direct call: 26,801,328 ops/sec
• call: 23,957,516 ops/sec
• apply: 23,870,318 ops/sec
• bind: 23,693,872 ops/sec

Firefox 18 runs

direct call

1306.9M/s

call

1256.9M/s

apply

131.5M/s

bind

60.1M/s

Fastest: direct call (21.7x faster)

View exact numbers

✓ direct call: 1,306,948,096 ops/sec
• call: 1,256,928,768 ops/sec
• apply: 131,451,056 ops/sec
• bind: 60,148,696 ops/sec

Safari 11 runs

apply

472.8M/s

call

459.6M/s

direct call

443.1M/s

bind

27.2M/s

Fastest: apply (17.4x faster)

View exact numbers

✓ apply: 472,835,616 ops/sec
• call: 459,630,368 ops/sec
• direct call: 443,130,240 ops/sec
• bind: 27,196,532 ops/sec

Mobile Results:

Chrome 6 runs

direct call

9.9M/s

call

9.1M/s

bind

8.3M/s

apply

8.2M/s

Fastest: direct call (1.2x faster)

View exact numbers

✓ direct call: 9,947,577 ops/sec
• call: 9,058,684 ops/sec
• bind: 8,313,591 ops/sec
• apply: 8,246,992 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
direct call
bind
call
apply

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 12 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36

Browser/OS: Chrome 150 on Windows

View result in a separate tab

direct call

990.7M/s

bind

920.8M/s

apply

898.4M/s

call

888.8M/s

View exact numbers

Test name	Executions per second
✓ direct call	990,735,296 Ops/sec
bind	920,807,040 Ops/sec
apply	898,355,008 Ops/sec
call	888,829,440 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of four different ways to invoke a function: `direct call`, `bind`, `call`, and `apply`. The test is designed to measure which approach is fastest.

**Test Cases**

Each test case defines a specific way to invoke the `test` function, which is initially defined with a simple script preparation code:
```javascript
function test(msg) {
  var d = msg;
}
```
The test cases are:

1. **Direct Call**: `test("Hello");`
2. **Bind**: `test.bind(null, "Hello")();`
3. **Call**: `test.call(null, "Hello");`
4. **Apply**: `test.apply(null, ["Hello"]);`

**Comparison**

When the `bind`, `call`, and `apply` methods are invoked, they modify the behavior of the `test` function. Here's what happens:

* **Bind**: The `bind` method sets the context (this) of the function to a specific value (`null` in this case). When the bound function is called, it will execute with that context.
* **Call**: The `call` method sets the context (this) of the function to a specific value (`null` in this case) and passes an argument list (`"Hello"`).
* **Apply**: The `apply` method sets the context (this) of the function to a specific value (`null` in this case) and passes an argument array (`["Hello"]`) as its first argument.

**Library**

The test cases use the built-in JavaScript methods `bind`, `call`, and `apply`. These methods are part of the ECMAScript standard and are implemented by most modern browsers.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

* **Direct Call**: Fastest, but requires passing arguments explicitly. No overhead from method invocation.
* **Bind**: More verbose than direct call, but allows for more flexibility in function invocation. Sets context (this) to specified value.
* **Call**: Similar to bind, but passes argument list explicitly. Can be faster than bind if the context is already set correctly.
* **Apply**: Most verbose of all methods, as it requires passing an array of arguments. However, can be useful when working with functions that require multiple arguments.

**Considerations**

When choosing between these approaches, consider the trade-offs:

* Speed: Direct call is generally fastest.
* Flexibility: Bind and call offer more flexibility in function invocation.
* Verbose: Apply is the most verbose method.

**Alternatives**

Other alternatives to this benchmark could include:

* Using a different function invocation syntax, such as arrow functions (`() => { ... }`) or generators/iterators.
* Measuring performance with different JavaScript engines (e.g., V8 vs. SpiderMonkey).
* Adding additional variables or dependencies to the test cases to measure their impact on performance.

Overall, this benchmark provides a useful comparison of function invocation methods in JavaScript, helping developers understand the trade-offs involved in choosing the right approach for their use case.

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

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

Created: 9 years ago by: Guest

Go to the latest result

direct call

bind

call

apply

Historical Performance Data aggregated from 121 community runs

Desktop Results:

Chrome 86 runs

Firefox 18 runs

Safari 11 runs

Mobile Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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

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

Created: 9 years ago by: Guest

Go to the latest result

direct call

bind

call

apply

Historical Performance Data aggregated from 121 community runs

Desktop Results:

Chrome 86 runs

Firefox 18 runs

Safari 11 runs

Mobile Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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