Benchmark: Direct call vs saved bind vs inline bind vs call vs apply vs closure

Script Preparation code:

function test(msg) {
    var d = msg;
}
var boundTest = test.bind("Hello");
var closure = () => test("Hello");

Tests:

direct call
test("Hello");
saved bind
boundTest();
inline bind
test.bind(null, "Hello")();
call
test.call(null, "Hello");
apply
test.apply(null, ["Hello"]);
closure
closure()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
direct call
saved bind
inline bind
call
apply
closure

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what is tested, compared, and their pros and cons.

**Benchmark Definition**

The test case uses a simple JavaScript function `test(msg)` that takes a message as an argument. The script preparation code defines two additional functions: `boundTest` (saved bind) and `closure`. These functions are used to test different binding methods.

*   `test("Hello")`: A direct call to the original `test` function.
*   `boundTest()`: Calls the `test` function with a specific message using saved bind (`bind` method).
*   `test.bind(null, "Hello")()`: Calls the bound version of `test` (inline bind) without explicitly calling it.
*   `test.call(null, "Hello")`: Calls the original `test` function with a specific message using the `call` method.
*   `test.apply(null, ["Hello"])`: Calls the original `test` function with an array argument using the `apply` method.
*   `closure()`: A self-contained function that calls the original `test` function with a specific message.

**Benchmarked Methods**

The test case compares five different methods for binding or calling functions:

1.  **Direct Call**: Calls the original function directly (`test("Hello")`).
    *   Pros: Simple and straightforward.
    *   Cons: May not be optimized or cached, leading to slower execution times.
2.  **Saved Bind (bind)**: Creates a new bound version of the function using `bind`.
    *   Pros:
        *   Can be used with multiple arguments.
        *   Allows for easy method chaining.
    *   Cons:
        *   May not work correctly when called without explicitly invoking it.
3.  **Inline Bind (bind)**: Creates a new bound version of the function directly on the object, often implicitly invoked using `()` or `()`.
    *   Pros:
        *   More concise than saved bind.
        *   Can be used with multiple arguments.
    *   Cons:
        *   May not work correctly when called without explicitly invoking it.
4.  **Call**: Calls the original function directly, but passes in an object to simulate a call using `call`.
    *   Pros:
        *   Allows for easy method chaining.
        *   Works even if the function isn't bound or is missing.
    *   Cons:
        *   May lead to unnecessary object creation.
5.  **Apply**: Calls the original function directly, passing an array to simulate a call using `apply`.
    *   Pros:
        *   Allows for easy method chaining with multiple arguments.
        *   Works even if the function isn't bound or is missing.
    *   Cons:
        *   May lead to unnecessary object creation.

**Library and Syntax**

The benchmark does not explicitly use any libraries. However, it does utilize JavaScript features like `bind`, `call`, and `apply`.

*   **Bind**: Used for creating a new bound version of the function (`boundTest = test.bind("Hello");`).
*   **Call and Apply**: Used for calling functions with specific arguments or arrays (e.g., `test.call(null, "Hello")`).

**Alternative Approaches**

Other methods that could be tested in this benchmark include:

1.  **Arrow Functions**: Could potentially offer better performance due to fewer overheads compared to traditional function expressions.
2.  **Async/Await**: Might not apply directly to the simple call scenarios but may provide a more efficient execution model when dealing with complex asynchronous code.
3.  **Closures**: The benchmark already tests closures (`closure()`), but exploring additional closure-related optimizations or trade-offs could be interesting.

**Keep in mind that JavaScript is a dynamically typed language, and its execution environment can vary between engines (e.g., V8 in Chrome/Node.js, SpiderMonkey in Firefox). This might lead to differences in performance across different browsers or engines.

Latest run results:

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

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

Browser/OS: Firefox 112 on Windows

View result in a separate tab

Test name	Executions per second
direct call	827941824.0 Ops/sec
saved bind	85249080.0 Ops/sec
inline bind	42363032.0 Ops/sec
call	786095680.0 Ops/sec
apply	80231592.0 Ops/sec
closure	785275584.0 Ops/sec

Related benchmarks:

Direct call vs saved bind vs inline bind vs call vs apply vs closure (version: 0)

Comparing performance of: direct call vs saved bind vs inline bind vs call vs apply vs closure

Created: one year ago by: Guest

Jump to the latest result

direct call

saved bind

inline bind

call

apply

closure

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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