Benchmark: Arrow vs Fun vs Arrow No Closure

Script Preparation code:

function normalFn() {
  return "test"
}

var arrowFnNoClosure = () => "test";

var arrowFnWithClosure = () => {
  return "test";
}

Tests:

Legacy
var result = normalFn();
Arrow No Closure
var result =arrowFnNoClosure();
Arrow w/ Closure
var result = arrowFnWithClosure();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Legacy
Arrow No Closure
Arrow w/ Closure

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark is designed to compare the performance of three different function declaration approaches in JavaScript: traditional functions (legacy), arrow functions without closures, and arrow functions with closures.

**Function Declaration Approaches**

1. **Traditional Functions (Legacy)**
	* Pros:
		+ Easy to understand and write
		+ Flexibility to use multiple statements inside the function body
		+ Can be used with any JavaScript version
	* Cons:
		+ May lead to slower performance due to function creation overhead
2. **Arrow Functions without Closures (Arrow No Closure)**
	* Pros:
		+ More concise and readable than traditional functions
		+ Does not create a new scope, potentially reducing overhead
	* Cons:
		+ Limited functionality compared to traditional functions
3. **Arrow Functions with Closures (Arrow w/ Closure)**
	* Pros:
		+ Combines the benefits of arrow functions with the ability to create closures
		+ May offer better performance due to reduced scope creation
	* Cons:
		+ Can be less readable than traditional functions or arrow functions without closures

**Library and Special Features**

There are no libraries used in this benchmark. However, it's worth noting that the use of arrow functions is a modern JavaScript feature introduced in ECMAScript 2015 (ES6).

**Benchmark Preparation Code**

The script preparation code provides two examples of each function declaration approach:

* `normalFn()`: A traditional function with a single statement body.
* `arrowFnNoClosure()`: An arrow function without a closure, returning a string literal.
* `arrowFnWithClosure()`: An arrow function with a closure, also returning a string literal.

The HTML preparation code is empty, indicating that no HTML-specific tests are included in this benchmark.

**Test Cases**

There are three test cases:

1. **Legacy**: Tests the execution of a traditional function (`normalFn()`).
2. **Arrow No Closure**: Tests the execution of an arrow function without a closure (`arrowFnNoClosure()`).
3. **Arrow w/ Closure**: Tests the execution of an arrow function with a closure (`arrowFnWithClosure()`).

**Benchmark Results**

The latest benchmark results show the performance data for each test case:

* `Arrow w/ Closure`: 182,111,174 executions per second
* `Legacy`: 181,989,680 executions per second
* `Arrow No Closure`: 180,443,860 executions per second

These results suggest that arrow functions with closures outperform traditional functions and arrow functions without closures in this benchmark.

**Other Alternatives**

If you're interested in exploring alternative approaches to function declaration, consider the following:

* **Function Expressions**: Instead of using `function` keywords, you can use the `Function` constructor or a function expression (e.g., `new Function()`, `var func = function () { ... }`).
* **Modules**: In modern JavaScript, you can define functions as module exports using ES6 modules (e.g., `export default function () { ... }`).
* **Generators and Closures**: You can use generators or closures to create more complex functions that don't require the traditional function declaration syntax.

Keep in mind that these alternatives may offer different performance characteristics, readability, or maintainability trade-offs compared to traditional function declarations.

Latest run results:

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

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

Browser/OS: Chrome 93 on Windows

View result in a separate tab

Test name	Executions per second
Legacy	18198968.0 Ops/sec
Arrow No Closure	18044386.0 Ops/sec
Arrow w/ Closure	18211174.0 Ops/sec

Related benchmarks:

Arrow vs Fun vs Arrow No Closure (version: 0)

Comparing performance of: Legacy vs Arrow No Closure vs Arrow w/ Closure

Created: 3 years ago by: Guest

Jump to the latest result

Legacy

Arrow No Closure

Arrow w/ Closure

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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