Benchmark: forEach vs reduce vs map vs filter vs for j--

Script Preparation code:

var arr = [];
for (var i = 0; i < 12345; i++) {
  arr[i] = i;
}

function someFn(i) {
  return (i * 3 * 8 / 1200 * 0.002 / 40 * 0.2);
}

var sumForEach = 0,
  sumReduce = 0,
  sumMap = 0,
  sumFilter = 0,
  sumFor = 0;

Tests:

forEach
arr.forEach(item => sumForEach += someFn(item));
reduce
sumReduce = arr.reduce((lastValue, item) => { return sumReduce += someFn(item); });
map
arr.map(item => (sumMap += someFn(item)));
filter
arr.filter(item => (sumFilter += someFn(item)));
for
for (var j = arr.length-1; j >= 0 ; j--) { sumFor += arr[j]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
reduce
map
filter
for

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 85 on Windows 7

View result in a separate tab

Test name	Executions per second
forEach	182.2 Ops/sec
reduce	182.5 Ops/sec
map	174.8 Ops/sec
filter	179.9 Ops/sec
for	191.3 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of four different JavaScript array operations: `forEach`, `reduce`, `map`, and `filter`. The test case creates an array of 12,345 elements and defines a mathematical function `someFn` that is applied to each element.

**Operation Comparison**

1. **forEach**: Iterates over the array using a callback function, executing it once for each element.
	* Pros: Simple, easy to understand, and suitable for operations with no side effects.
	* Cons: Can be slower than other methods due to the overhead of creating a new scope and executing the callback function.
2. **reduce**: Accumulates a value by applying a callback function to each element in the array, reducing it to a single output value.
	* Pros: Suitable for aggregating values or transforming data into a single output value.
	* Cons: Can be slower than `forEach` due to the additional overhead of accumulating values.
3. **map**: Creates a new array by applying a callback function to each element in the original array, returning a new array with transformed values.
	* Pros: Suitable for creating new arrays or transforming data into different formats.
	* Cons: Can be slower than `forEach` due to the overhead of creating a new array and executing the callback function.
4. **filter**: Creates a new array containing only elements that pass the test implemented by the provided callback function.
	* Pros: Suitable for filtering out unwanted data or selecting specific elements.
	* Cons: Can be slower than `forEach` due to the overhead of testing each element.

**Other Considerations**

* The `for` loop is used as a reference point, but its performance can vary depending on the specific implementation and the size of the array.
* The test case uses a mathematical function `someFn` that is not optimized for performance. In a real-world scenario, this would likely be replaced with a more efficient algorithm.

**Library Usage**

The benchmark does not use any external libraries, but it relies on the built-in JavaScript functions and arrays to perform the operations.

**Special JS Features/Syntax**

The benchmark uses the `let` keyword for variable declaration (e.g., `var arr = []`) and arrow functions (e.g., `(item) => someFn(item)`). These are modern features introduced in ECMAScript 2015. The benchmark does not use any older syntax or features.

**Alternative Approaches**

Other alternatives to these operations include:

* Using a custom implementation using indexing and array manipulation
* Utilizing parallel processing or multi-threading to speed up the operations (not tested in this benchmark)
* Optimizing the mathematical function `someFn` for performance
* Using a different data structure, such as a linked list or a tree, instead of an array.

Keep in mind that the choice of approach depends on the specific use case and requirements. The original code uses JavaScript's built-in functions to demonstrate simplicity and readability.

Related benchmarks:

forEach vs reduce vs map vs filter vs for j-- (version: 0)

Comparing performance of: forEach vs reduce vs map vs filter vs for

Created: 4 years ago by: Guest

Jump to the latest result

forEach

reduce

map

filter

for

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