Benchmark: Direct call vs bind vs call vs apply vs static bound

Script Preparation code:

function test(msg) {
  var d = msg;
}

var testBound = test.bind(null);

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
direct call
bind
call
apply
static bind

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; rv:129.0) Gecko/20100101 Firefox/129.0

Browser/OS: Firefox 129 on Mac OS X 10.15

View result in a separate tab

direct call

1648.8M/s

call

1648.3M/s

static bind

309.3M/s

apply

308.3M/s

bind

139.5M/s

View exact numbers

Test name	Executions per second
✓ direct call	1,648,777,600 Ops/sec
call	1,648,324,992 Ops/sec
static bind	309,263,968 Ops/sec
apply	308,315,616 Ops/sec
bind	139,454,880 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 defines a benchmark that tests different approaches to calling functions in JavaScript:

1. Direct call (`test("Hello");`)
2. Binding using `bind` method (`test.bind(null, "Hello")()`)
3. Binding using `call` method (`test.call(null, "Hello")`)
4. Applying the function using `apply` method (`test.apply(null, ["Hello"])`)
5. Static binding (using a bound function) (`testBound("Hello")`)

**Options Compared**

The benchmark compares the performance of these different approaches:

* Direct call: The original way of calling a function.
* Bind: A method that creates a new function with a specific `this` context.
* Call: A method that calls a function with a specified `this` context and arguments.
* Apply: A method that applies a function to an array of arguments, with the first argument as the `this` context.
* Static bind: A bound function created using `bind`, which is stored in memory.

**Pros and Cons**

Here's a brief summary:

* **Direct call**: Simple, but can lead to performance issues due to the overhead of creating a new function context.
* **Bind**: Can be useful when you need to set the `this` context for a function, but creates a new function object that may have additional overhead.
* **Call**: Similar to bind, but applies to an array of arguments. Can be slower than direct call due to the additional work.
* **Apply**: Faster than call because it only needs to create a new execution context with the specified `this` and arguments. However, it can lead to issues when working with function pointers or multiple argument passing.
* **Static bind**: The most efficient approach, as the bound function is stored in memory, avoiding the overhead of creating a new function object.

**Library: Function**

The benchmark uses JavaScript's built-in `Function` constructor and methods (`bind`, `call`, and `apply`) to test different approaches. No external libraries are required.

**Special JS Feature/Syntax**

This benchmark does not use any special features or syntax, such as async/await, generators, or closures. It only focuses on basic function calling mechanics.

**Other Alternatives**

Some alternative approaches to binding functions in JavaScript include:

* **Arrow functions**: Create a new function with the `this` context set automatically using an arrow function.
* **Prototypal inheritance**: Use inheritance patterns (e.g., prototypal subclassing) to set up the `this` context for a function.
* **Function factories**: Create functions that return other functions, allowing you to control the `this` context.

Keep in mind that these alternatives may have different performance characteristics or use cases compared to the binding methods used in this benchmark.

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

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

Created: one year ago by: Guest

Go to the latest result

direct call

bind

call

apply

static bind

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 vs static bound (version: 0)

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

Created: one year ago by: Guest

Go to the latest result

direct call

bind

call

apply

static bind

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 vs static bind`