Benchmark: for-push vs filter

Script Preparation code:

var arr = Array.from({length: 10_000}, () => Math.floor(Math.random() * 2));

Tests:

for-push
var result = []; for (var i = 0; i < arr.length; i++) { var item = arr[i]; if (item !== 0) { result.push(item); } }
flatMap
arr.flatMap((x) => (x !== 0 ? [x] : []));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for-push
flatMap

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 104 on Windows

View result in a separate tab

Test name	Executions per second
for-push	800.9 Ops/sec
flatMap	816.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested.

**Benchmark Definition**

The benchmark compares the performance of two approaches: `flatMap` vs `for-push`. In this case, we're specifically comparing the performance of flat mapping an array using `Array.prototype.flatMap()` (in modern JavaScript) versus pushing elements to a new array using a traditional `for` loop (`for-push`).

**Options Compared**

The two options being compared are:

1. **flatMap**: A method that creates a new array with the results of applying a provided function on every element in this array. It short-circuits and returns as soon as the first source array is exhausted.
2. **For-Push (for-push)**: A traditional approach where you create an empty array and then iterate over the original array, pushing each non-zero element to the new array.

**Pros and Cons**

**flatMap**:

Pros:

* More concise and expressive code
* Optimized for performance in modern browsers

Cons:

* May not work well with older browsers or environments that don't support `Array.prototype.flatMap()`
* Can be less readable for developers unfamiliar with modern JavaScript features

**For-Push (for-push)**:

Pros:

* Wide browser compatibility (works on older browsers and environments)
* More readable code for developers familiar with traditional iteration patterns
* No reliance on a specific JavaScript feature or library

Cons:

* Less concise and potentially more verbose code
* May be slower due to the overhead of pushing elements to an array

**Library: Array.prototype.flatMap()**

The `Array.prototype.flatMap()` method is a part of the modern JavaScript standard and is supported by most modern browsers. It's designed to provide a concise and efficient way to flat map arrays, making it a popular choice for many developers.

**Special JS Feature/Syntax: None in this case**

There are no special JavaScript features or syntax used in this benchmark that require specific knowledge of modern JavaScript or its quirks.

**Other Alternatives**

For older browsers or environments that don't support `Array.prototype.flatMap()`, you could use other methods like:

* `Array.prototype.map()` and then spreading the result into a new array using the spread operator (`...`)
* Using a library like Lodash (which provides an implementation of `flatMap`)

Keep in mind that these alternatives may introduce additional overhead or changes to the code, potentially affecting performance.

Related benchmarks:

for-push vs filter (version: 0)

Comparing performance of: flatMap vs for-push

Comparing performance of: for-push vs flatMap

Created: one year ago by: Guest

Jump to the latest result

for-push

flatMap

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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