Benchmark: Arrow function vs function comparison

Tests:

Arrow function
const arrowFn = (a, b) => a + b; arrowFn()
Normal function
function fn(a, b) { return a + b; } fn()

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Normal function

168.3M/s

Arrow function

162.0M/s

View exact numbers

✓ Normal function: 168,333,328 ops/sec
• Arrow function: 161,997,088 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
Arrow function
Normal function

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 144 on Windows

View result in a separate tab

Normal function

153.3M/s

Arrow function

138.4M/s

View exact numbers

Test name	Executions per second
✓ Normal function	153,258,800 Ops/sec
Arrow function	138,428,400 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 its components.

**Benchmark Definition:**

The benchmark is defined as a comparison between two approaches: arrow functions and regular functions in JavaScript. The benchmark aims to determine which approach has better performance in terms of execution speed.

**Script Preparation Code:**

Since there is no script preparation code provided, we'll assume that the scripts are empty or already prepared for testing.

**Html Preparation Code:**

There is also no html preparation code provided, so we'll proceed with the assumption that the HTML setup is not relevant to the benchmark's outcome.

**Individual Test Cases:**

We have two test cases:

1. **Arrow Function:** The first test case defines an arrow function `arrowFn` that takes two parameters `a` and `b` and returns their sum.
2. **Normal Function:** The second test case defines a regular function `fn` with the same logic as the arrow function.

**Comparison:**

The benchmark compares the execution speed of both approaches on the same input values (likely integers). The results are measured in executions per second, which indicates how many times each approach can execute the code within one second.

**Pros and Cons of Each Approach:**

* **Arrow Functions:**
	+ Pros:
		- More concise and readable code
		- Less syntax overhead compared to regular functions
	+ Cons:
		- May have slower execution speed due to additional bytecode generation
		- Less control over function behavior (e.g., no `this` keyword)
* **Regular Functions:**
	+ Pros:
		- More control over function behavior and performance
		- Can be more efficient in certain cases (e.g., when using `with` statements or complex logic)
	+ Cons:
		- More verbose code compared to arrow functions
		- Additional syntax overhead

**Library:**

There is no explicit library mentioned in the benchmark definition. However, JavaScript engines like V8 (used by Google Chrome) and SpiderMonkey (used by Mozilla Firefox) may use various internal optimizations or libraries that could affect the performance of these functions.

**Special JS Feature/Syntax:**

No special JavaScript features or syntax are mentioned in the benchmark definition. It's likely that this is an effort to keep the benchmark focused on a specific aspect of JavaScript performance, avoiding any potential variations caused by other language features.

**Other Alternatives:**

To further investigate performance differences between arrow functions and regular functions, you might consider exploring other alternatives:

1. **Generator Functions:** Another concise syntax for defining functions that can be used instead of arrow functions.
2. **Async/Await:** For asynchronous code execution, which might affect the performance comparison due to different execution models.
3. **Closure-based implementations:** Using closures to encapsulate logic and potentially influencing performance.
4. **Other optimizations:** Considering various optimization techniques like caching, memoization, or parallel processing.

Keep in mind that these alternatives may not directly compare to arrow functions and regular functions, but exploring them can provide more comprehensive insights into JavaScript performance characteristics.

Arrow function vs function comparison (version: 0)

Comparing performance of: `Arrow function vs Normal function`

Created: 3 years ago by: Guest

Go to the latest result

Arrow function

Normal function

Historical Performance Data aggregated from 6 community runs

Desktop 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):

Arrow function vs function comparison (version: 0)

Comparing performance of: Arrow function vs Normal function

Created: 3 years ago by: Guest

Go to the latest result

Arrow function

Normal function

Historical Performance Data aggregated from 6 community runs

Desktop 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: `Arrow function vs Normal function`