Benchmark: Arrow functions vs functions 2

Script Preparation code:

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

Tests:

arrowFn
arrowFn(1,2)
fn
fn(1,2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
arrowFn
fn

Fastest: N/A

Slowest: N/A

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/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36

Browser/OS: Chrome 109 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
arrowFn	16493125.0 Ops/sec
fn	16849512.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its results to understand what's being tested.

**Benchmark Definition**

The benchmark is comparing two approaches: arrow functions and traditional functions (also known as function expressions). Both are used to define small, single-purpose functions that take two arguments (`a` and `b`) and return their sum.

**Script Preparation Code**

The script preparation code provides the implementation for both the arrow function (`arrowFn`) and the traditional function (`fn`). The main difference between them is how they declare their function body:

* Arrow function: `(a, b) => a + b`
	+ Pros:
		- Concise syntax
	+ Cons:
		- Limited control over function scope (no `this` binding)
* Traditional function: `function fn(a, b) { return a + b; }`
	+ Pros:
		- Better control over function scope
	+ Cons:
		- Longer syntax

**Html Preparation Code**

There is no HTML preparation code provided, so we can assume that the benchmark only focuses on JavaScript performance.

**Individual Test Cases**

We have two test cases:

1. `arrowFn(1, 2)`
2. `fn(1, 2)`

These test cases call each function with specific input arguments and measure their execution time.

**Latest Benchmark Result**

The results show the performance of both functions on a Chrome 109 browser on a Mac OS X 10.15.7 device:

| Test Name | ExecutionsPerSecond |
| --- | --- |
| fn | 164,93125.0 |
| arrowFn | 168,49512.0 |

**Library and Special JS Features**

There are no libraries or special JavaScript features mentioned in the benchmark definition.

**Other Alternatives**

For a more comprehensive understanding of function performance in JavaScript, you may want to explore benchmarks for other aspects, such as:

* Looping and iteration
* Array and object manipulation
* Object creation and instantiation
* Closure and scoping

Some popular resources for JavaScript performance benchmarking include:

* js-bench: A benchmarking framework specifically designed for JavaScript.
* Benchmark.js: A lightweight benchmarking library for Node.js and browser-based applications.
* Perf Benchmarks: A collection of benchmark suites for various programming languages, including JavaScript.

Keep in mind that benchmarking is an active area of research, and results may vary depending on the specific use case and environment.

Related benchmarks:

Arrow functions vs functions 2 (version: 0)

Comparing performance of: arrowFn vs fn

Created: one year ago by: Guest

Jump to the latest result

arrowFn

fn

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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