Benchmark: Benchmark: flatMap vs reduce vs while vs foreach

Script Preparation code:

var n = 1000

Tests:

flatMap
[...Array(n)].flatMap((x,i) => [++i,i++])
reduce
[...Array(n).keys()].reduce((acc, cur) => [...acc, ++cur, cur++], [])
while
let res = [], i=0; while(n>i++) res.push(i, i);
foreach
let res = []; Array(n).forEach((_,i) => res.push(i+1, i+1))

Historical Performance Data aggregated from 46 community runs

Desktop Results:

Chrome 39 runs

foreach

435K/s

while

33K/s

flatMap

21K/s

reduce

1K/s

Fastest: foreach (408.6x faster)

View exact numbers

✓ foreach: 435,056 ops/sec
• while: 32,952 ops/sec
• flatMap: 20,510 ops/sec
• reduce: 1,065 ops/sec

Firefox 7 runs

foreach

893K/s

while

51K/s

flatMap

30K/s

reduce

144/s

Fastest: foreach (6198.3x faster)

View exact numbers

✓ foreach: 893,200 ops/sec
• while: 50,611 ops/sec
• flatMap: 30,454 ops/sec
• reduce: 144 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
flatMap
reduce
while
foreach

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; rv:147.0) Gecko/20100101 Firefox/147.0

Browser/OS: Firefox 147 on Windows

View result in a separate tab

foreach

506K/s

while

22K/s

flatMap

17K/s

reduce

76/s

View exact numbers

Test name	Executions per second
✓ foreach	506,152 Ops/sec
while	21,904 Ops/sec
flatMap	16,527 Ops/sec
reduce	76 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 explain what's being tested, compared, and some pros and cons of each approach.

**Benchmark Description**

The benchmark is designed to compare the performance of four different JavaScript iteration methods: `flatMap`, `reduce`, `while`, and `foreach`. The test case generates an array of length 1000 using `[...Array(n)].` and then applies one of these methods to it.

**What's being tested?**

Each test case measures the execution time of each iteration method on a large array of 1000 elements. This allows us to compare the performance of each method under similar conditions.

**Options compared**

* `flatMap`: Flattens an array by mapping over its elements and returning an array of results.
* `reduce`: Reduces an array by iterating over its elements and applying a reduction function to each element.
* `while`: Uses a traditional loop with a counter variable (`i`) to iterate over the array.
* `foreach` (also known as `forEachLoop` in some versions of JavaScript): Iterates over an array using a callback function.

**Pros and Cons**

* **flatMap**:
	+ Pros: Efficient and concise way to flatten arrays, can be more readable than traditional loops.
	+ Cons: May not work correctly with nested arrays or non-array iterables.
* **reduce**:
	+ Pros: Can be used for aggregating values, allows for more control over the iteration process.
	+ Cons: Can be slower and less readable than other methods, especially for large datasets.
* **while**:
	+ Pros: Allows for fine-grained control over the loop, can be useful when working with legacy code or specific requirements.
	+ Cons: Can be error-prone and harder to read than other methods, especially for complex logic.
* **foreach** (also known as `forEachLoop`):
	+ Pros: Simple and readable way to iterate over arrays, easy to understand for developers familiar with other languages.
	+ Cons: Not optimized for performance, may not be suitable for large datasets.

**Library and special JS feature**

None of the test cases rely on external libraries or specific JavaScript features (like async/await, arrow functions, etc.). The focus is solely on comparing the performance of different iteration methods.

**Other alternatives**

If you're interested in exploring alternative iteration methods, some examples include:

* `forEach` with a `for...of` loop: While not as optimized as other methods, this can be a good option when readability is more important than performance.
* `map`, `filter`, and `every` methods for more complex data transformations.
* `Array.prototype.some()` or `Array.prototype.every()` for iterating over arrays with callback functions.

Keep in mind that the choice of iteration method depends on the specific requirements of your project, such as performance, readability, and maintainability.

Benchmark: flatMap vs reduce vs while vs foreach (version: 0)

Comparing performance of: `flatMap vs reduce vs while vs foreach`

Created: 5 years ago by: Guest

Go to the latest result

flatMap

reduce

while

foreach

Historical Performance Data aggregated from 46 community runs

Desktop Results:

Chrome 39 runs

Firefox 7 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Benchmark: flatMap vs reduce vs while vs foreach (version: 0)

Comparing performance of: flatMap vs reduce vs while vs foreach

Created: 5 years ago by: Guest

Go to the latest result

flatMap

reduce

while

foreach

Historical Performance Data aggregated from 46 community runs

Desktop Results:

Chrome 39 runs

Firefox 7 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: `flatMap vs reduce vs while vs foreach`