Benchmark: Arrow function vs normal function

Script Preparation code:

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

Tests:

Arrow function
arrowFn()
Closure function
fn()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Arrow function
Closure function

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The provided JSON represents a benchmark test comparing two approaches: arrow functions and traditional functions (also known as "closure functions"). The script preparation code defines two functions:

* `arrowFn`: an arrow function that takes two arguments, `a` and `b`, and returns their sum.
* `fn`: a traditional function (using the `function` keyword) that also takes two arguments, `a` and `b`, and returns their sum.

**Options Compared**

The benchmark tests the performance of these two approaches on the same code. Specifically:

* The number of executions per second (ExecutionsPerSecond) is measured for each browser version.
* Both arrow functions and traditional functions are tested to determine which approach is faster.

**Pros and Cons**

* **Arrow Functions**: These offer several benefits, including:
	+ Concise syntax
	+ No explicit `return` statement required
	+ Reduced memory allocation (no need to create a function scope)
	+ Faster execution (due to reduced overhead in the interpreter)
* Traditional Functions (Closure Functions):
	+ More flexible and expressive syntax
	+ Can be used with `this` context binding
	+ Easier to read and maintain, especially for complex logic

However, traditional functions also come with some drawbacks:

* Larger memory footprint due to function creation
* More verbose syntax
* Slower execution compared to arrow functions

**Library Usage**

None of the test cases use any external libraries. The code is self-contained, relying only on JavaScript's built-in features.

**Special JS Features/Syntax**

No special JavaScript features or syntax are mentioned in this benchmark. However, it's worth noting that some features like `let` and `const` (used to declare variables) were introduced in ECMAScript 2015, which might not be supported by all browsers used in the test.

**Other Alternatives**

If you're interested in comparing other approaches or libraries, here are a few alternatives:

* **Template literals**: These can offer better performance than concatenation or string interpolation for some use cases.
* **Async functions**: If you need to write asynchronous code, async functions might be a better choice than traditional functions.
* **Generator functions**: Generator functions can provide more flexibility when dealing with complex iteration logic.

For this specific benchmark, though, the comparison between arrow functions and traditional functions provides a clear insight into their relative performance characteristics.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15

Browser/OS: Safari 17 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Arrow function	9645371.0 Ops/sec
Closure function	9444812.0 Ops/sec

Related benchmarks:

Arrow function vs normal function (version: 0)

Comparing performance of: Arrow function vs Closure function

Created: 3 years ago by: Guest

Jump to the latest result

Arrow function

Closure function

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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