Benchmark: Direct call v bind

Script Preparation code:

class X {
  test(msg) { return this; }
}
x = new X();
bound = x.test.bind(x);
wrapped = (msg) => x.test(msg);

Tests:

direct call
x.test("Hello");
x.bind
bound("Hello");
call
wrapped("Hello")

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
direct call
x.bind
call

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 101 on Windows

View result in a separate tab

Test name	Executions per second
direct call	6482555.0 Ops/sec
x.bind	6589440.0 Ops/sec
call	2926174.8 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months 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 is designed to compare the performance of three different approaches:

1. **Direct Call**: Calling the `test` method directly on the instance `x`.
2. **Bound Function**: Using the `bind` method to create a new function that calls `test` with the context of `x`.
3. **Wrapped Function**: Wrapping the call to `test` in an anonymous function (`wrapped`) that also has `x` as its context.

**Options Compared**

The benchmark is testing three different options:

1. **Direct Call**: This approach involves calling the method directly on the instance, without any additional setup.
2. **Bound Function**: This approach uses the `bind` method to create a new function that calls the original method with the correct context.
3. **Wrapped Function**: This approach wraps the call to the method in an anonymous function that also has the correct context.

**Pros and Cons of Each Approach**

1. **Direct Call**:
	* Pros: Simple, no additional setup required.
	* Cons: May incur overhead due to method lookups or bound checking.
2. **Bound Function**:
	* Pros: Can improve performance by avoiding method lookups or bound checking.
	* Cons: Requires an extra step to create the bound function using `bind`.
3. **Wrapped Function**:
	* Pros: Can provide a layer of abstraction and encapsulation, making it easier to reuse code.
	* Cons: May incur additional overhead due to function creation and invocation.

**Library and Special JS Features**

In this benchmark, the following library is used:

1. **Function.prototype.bind()**: This method creates a new bound function that calls the original function with the specified context.

No special JavaScript features are required for this benchmark.

**Benchmark Results**

The latest benchmark results show the performance of each approach across different browsers and devices. The top result shows that the `x.bind` approach performs best, followed closely by the direct call, and then the wrapped function.

**Alternative Approaches**

Other approaches could be explored, such as:

1. **Closures**: Using a closure to encapsulate the method call and provide the correct context.
2. **Proxy Objects**: Creating a proxy object that intercepts method calls and provides the correct context.
3. **Function expression**: Using a function expression instead of `bind` or wrapping.

These alternatives might offer different trade-offs in terms of performance, code complexity, and maintainability.

Related benchmarks:

Direct call v bind (version: 0)

Comparing performance of: direct call vs x.bind vs call

Created: 2 years ago by: Guest

Jump to the latest result

direct call

x.bind

call

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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