Benchmark: Noop vs new arrow function call

Script Preparation code:

window.noop = () => {};

Tests:

Noop
noop();
New arrow function
(() => {})();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Noop
New arrow function

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 5 months ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 18 on iOS 18.6

View result in a separate tab

Test name	Executions per second
Noop	478060896.0 Ops/sec
New arrow function	162772720.0 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 JSON and explain what's being tested, compared, and the pros and cons of each approach.

**Benchmark Definition**

The benchmark definition is represented by two script preparation codes:

1. `window.noop = () => {};;` - This code creates a new empty function on the global window object and assigns it to the `noop` variable.
2. `(() => {})();` - This code defines an immediately invoked arrow function expression (IIFE) that returns an empty object.

**Test Cases**

There are two individual test cases:

1. **Noop**: The benchmark definition is simply calling the `noop()` function.
2. **New Arrow Function**: The benchmark definition is the execution of the IIFE `(() => {})();`.

**Library and Special JS Features**

In this benchmark, no external libraries or special JavaScript features are used.

**Benchmark Comparison**

The two test cases compare:

* Creating an empty function on the global window object using `window.noop = () => {};;` versus
* Defining an immediately invoked arrow function expression (IIFE) with a return statement `(() => {})();`

Both approaches create or define an empty value, but they use different syntax and semantics.

**Pros and Cons**

1. **Using `window.noop = () => {};;`**:
	* Pros: This approach creates a global variable that can be used elsewhere in the codebase.
	* Cons: It may have performance implications due to its creation on the global scope, which can lead to slower execution times compared to other approaches.
2. **Using `(() => {})();`**:
	* Pros: This approach is concise and creates an immediately available value without polluting the global scope.
	* Cons: It's a more complex syntax that may be less readable or maintainable for some developers.

**Other Alternatives**

Some alternative approaches could be:

1. Using a different data type, such as `undefined` or `null`, to represent an empty value.
2. Creating a local variable instead of using the global window object.
3. Using a library like Lodash's `constant()` function to create a constant value.

However, these alternatives might not be relevant in this specific benchmark, as they don't change the fundamental comparison between creating an empty function or an IIFE with a return statement.

**Benchmark Results**

The latest benchmark result shows that:

* The new arrow function (`(() => {})();`) executed approximately 102.7 million times per second on Chrome 104 on a desktop machine running Mac OS X 10.15.7.
* The `noop()` function executed approximately 14.6 million times per second under the same conditions.

This suggests that the new arrow function has a better performance profile in this specific benchmark, likely due to its concise syntax and local scope creation.

Related benchmarks:

Noop vs new arrow function call (version: 0)

Comparing performance of: Noop vs New arrow function

Created: 3 years ago by: Guest

Jump to the latest result

Noop

New arrow function

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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