Benchmark: flatten : Array.flat() vs Ramda

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.27.0/ramda.min.js"></script>

Script Preparation code:

var data = R.range(0, 10000).map(function(i) {
      return Math.floor(Math.random() * i) % 2 === 0 ? R.range(0, 3) : i;
  });

Tests:

Ramda
const result = R.flatten(data)
Array.flat()
const result = data.flat()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Ramda
Array.flat()

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36 Edg/137.0.0.0

Browser/OS: Chrome 137 on Linux

View result in a separate tab

Test name	Executions per second
Ramda	2836.6 Ops/sec
Array.flat()	3318.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested on the provided JSON data for the JavaScript microbenchmark.

**Benchmark Purpose:**
The purpose of this benchmark is to compare the performance of two approaches: `Array.flat()` and Ramda's `flatten` function. The goal is to determine which approach is faster when flattening a large array with varying levels of depth.

**Options Compared:**

1. **Array.flat():** This method uses a simple iterative approach to flatten an array by creating a new array and adding elements from the original array one by one.
2. **Ramda's `flatten`:** Ramda is a functional programming library that provides various utility functions, including `flatten`. This function takes an array as input and returns a new array with all elements flattened.

**Pros and Cons:**

* **Array.flat():**
	+ Pros:
		- Simple implementation.
		- Fast execution, especially for large arrays.
	+ Cons:
		- Can be slower than Ramda's `flatten` for smaller arrays due to the overhead of creating a new array.
* **Ramda's `flatten`:**
	+ Pros:
		- More concise and expressive code.
		- Often faster than `Array.flat()` for larger arrays due to optimized implementation.
	+ Cons:
		- Can be slower for very small arrays due to the overhead of function calls.

**Library and Its Purpose:**
Ramda is a functional programming library that provides various utility functions, including `flatten`, which is used in this benchmark. Ramda's `flatten` function takes an array as input and returns a new array with all elements flattened.

**Special JS Feature or Syntax:**
There are no special JavaScript features or syntaxes mentioned in the provided JSON data.

**Other Alternatives:**
If you want to use other approaches for flattening arrays, some alternatives include:

* Using `Array.prototype.reduce()` to flatten an array:
```javascript
const result = arr.reduce((acc, val) => acc.concat(val), []);
```
* Using a loop and concatenating elements manually:
```javascript
const result = [];
for (let i = 0; i < arr.length; i++) {
    if (Array.isArray(arr[i])) {
        result.push(...arr[i]);
    } else {
        result.push(arr[i]);
    }
}
```
However, these approaches are generally slower and less concise than using `Array.flat()` or Ramda's `flatten`.

**Benchmark Results:**
The latest benchmark results show that Chrome 130 performs slightly better for the `Array.flat()` approach (5145.42626953125 executions per second) compared to the Ramda `flatten` function (4775.251953125 executions per second). However, the difference is relatively small, and both approaches are fast.

Overall, this benchmark provides a useful comparison of two approaches for flattening arrays in JavaScript, highlighting the trade-offs between simplicity, conciseness, and performance.

Related benchmarks:

flatten : Array.flat() vs Ramda (version: 0)

Comparing performance of: Ramda vs Array.flat()

Created: 4 years ago by: Guest

Jump to the latest result

Ramda

Array.flat()

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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