Benchmark: MapFilter vs ForEach

Script Preparation code:

function guid() {
  function s4() {
    return Math.floor((1 + Math.random()) * 0x10000)
      .toString(16)
      .substring(1);
  }
  return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
}

arr = [];
for (let i = 0; i < 1000; i++) {
  arr[i] = { id: i, value: guid() }
}

Tests:

ForEach
let result = []; arr.forEach(e => { if (e.id % 7 === 0 || e.id % 13 === 2) { result.push({ text: 'id: ' + e.value, value: e.id }); } });
MapFilter
result = arr.filter(e => e.id % 7 === 0 || e.id % 13 === 2).map(e => ({ text: 'id: ' + e.value, value: e.id }))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
ForEach
MapFilter

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark definition specifies two test cases:

1. **MapFilter**: This test case uses the `filter()` method to create a new array with elements that satisfy a specific condition (in this case, `e.id % 7 === 0 || e.id % 13 === 2`). The resulting array is then mapped over using the `map()` method to transform each element into an object with two properties: `text` and `value`.
2. **ForEach**: This test case uses a traditional `for...of` loop to iterate over the array, applying a conditional statement to filter out elements based on the same condition as in MapFilter. The filtered elements are then pushed onto a new array called `result`.

**Options Compared**

The benchmark is comparing two approaches:

* **MapFilter**: Using the `filter()` and `map()` methods to create a new array with transformed elements.
* **ForEach**: Using a traditional `for...of` loop to iterate over the array, filtering out elements, and pushing them onto a new array.

**Pros and Cons**

* **MapFilter**:
	+ Pros: More concise code, potentially faster execution (since it avoids the overhead of a traditional loop).
	+ Cons: May have performance issues if the filtered array is very large (since `filter()` creates a new array), or if the transformation function is computationally expensive.
* **ForEach**:
	+ Pros: Can be more efficient for small to medium-sized datasets, as it avoids creating a new array and only iterates over the original array once. Also allows for early exit conditions.
	+ Cons: More verbose code, potentially slower execution compared to MapFilter (since it involves a loop).

**Other Considerations**

* The use of `guid()` function in the script preparation code generates random IDs for each element in the array, which helps to isolate the performance characteristics of the two test cases from other factors.
* The device platform and operating system specified in the benchmark result are likely used as control variables to account for potential hardware or software variations.

**Libraries and Special JS Features**

There is no explicitly mentioned library being used in this benchmark. However, some JavaScript features like `arrow functions` (`=>`) and `template literals` (`\r\narr.push(${text}: ${value})\r\n`) are implied but not directly utilized.

In the provided code, `for...of` loop is used which was introduced in ECMAScript 2015 (ES6) standard. This is not a special JS feature per se, but rather a new syntax for traditional loops.

**Alternatives**

Other alternatives to MapFilter and ForEach could include:

* Using other filtering methods like `some()` or `every()`
* Utilizing libraries like Lodash's `filterBy` function
* Employing more functional programming approaches, such as using `reduce()` or `reduceRight()`

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36

Browser/OS: Chrome 64 on Mac OS X 10.13.3

View result in a separate tab

Test name	Executions per second
ForEach	109385.0 Ops/sec
MapFilter	95377.7 Ops/sec

Related benchmarks:

MapFilter vs ForEach (version: 0)

Comparing performance of: ForEach vs MapFilter

Created: 6 years ago by: Guest

Jump to the latest result

ForEach

MapFilter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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