Benchmark: Object filtered Array loop vs foreach vs map vs while

Script Preparation code:

   var arr = [];
   for (var i = 0; i < 1000000; i++) {
       arr[i] = {Id:i};
   }

   var x = [];

Tests:

foreach if
arr.forEach(item => { if (!item%2) x.push(item.Id); })
filter foreach
x = arr.filter(item=>!item%2).forEach(item => { x.push(item.Id); })
filter map
x = arr.filter(item=>!item%2).map(item => item.Id)
while
let len = arr.length; while (len--) { let item = arr[len].Id; if (!item%2) x.push(item); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
foreach if
filter foreach
filter map
while

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_0_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 15 on iOS 15.0.2

View result in a separate tab

Test name	Executions per second
foreach if	199.9 Ops/sec
filter foreach	495.6 Ops/sec
filter map	403.1 Ops/sec
while	26.2 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 JSON and explain what's being tested, the options compared, pros and cons of each approach, library usage, special JavaScript features, and alternative approaches.

**Benchmark Definition**

The benchmark measures the performance of filtering an array using different methods: `forEach`, `map`, and a custom `while` loop. The script preparation code creates an array of 1 million objects with a unique `Id` property.

**Options Compared**

1. **`forEach`**: Iterates over the array, checking each element's parity (`%2`) and pushing its `Id` to another array if it's even.
2. **`filter` + `forEach`**: Filters out odd elements using `filter`, then iterates over the remaining elements using `forEach` and pushes their `Id` to another array.
3. **`map`**: Transforms each element of the original array into an object containing its `Id`, using `map`.
4. **Custom `while` loop**: Iterates over the array using a `while` loop, checking each element's parity (`%2`) and pushing its `Id` to another array.

**Pros and Cons**

* **`forEach`**:
	+ Pros: Simple and easy to read, no need to manually iterate over the array.
	+ Cons: May not be as efficient as other methods due to the overhead of function calls.
* **`filter` + `forEach`**:
	+ Pros: Combines filtering with iteration, reducing code complexity.
	+ Cons: Requires two separate operations (filtering and iteration), which may incur additional overhead.
* **`map`**:
	+ Pros: Can be faster than `forEach` for large datasets, as it uses a more efficient algorithm.
	+ Cons: May not work as expected if the transformed elements are not what you expect (e.g., if you need to access the original element's properties).
* Custom `while` loop:
	+ Pros: Provides direct control over iteration and can be optimized for performance.
	+ Cons: More verbose and error-prone than other methods.

**Library Usage**

None explicitly mentioned, but `forEach`, `filter`, and `map` are built-in JavaScript methods.

**Special JavaScript Features**

* No special features are used in this benchmark. The code relies on standard JavaScript syntax and features.

**Alternative Approaches**

1. **Using a for...of loop**: Instead of using `forEach`, you could use a `for...of` loop to iterate over the array.
2. **Using a Reduce() method**: You could use `reduce()` instead of `map` to accumulate the results in a single array.
3. **Using a custom function**: Depending on your specific requirements, you might be able to write a custom function that combines elements of different approaches.

Keep in mind that the choice of approach depends on your specific needs and performance requirements. This benchmark provides a good starting point for exploring different methods, but you may need to experiment with other options to find the best fit for your use case.

Related benchmarks:

Object filtered Array loop vs foreach vs map vs while (version: 0)

Comparing performance of: foreach if vs filter foreach vs filter map vs while

Created: 3 years ago by: Guest

Jump to the latest result

foreach if

filter foreach

filter map

while

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):