Benchmark: forEach vs reduce vs map vs filter vs for (slightly optimized for)

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 (let j = 0, len = arr.length; j < len; 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:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.1:latest, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is being tested?**

The benchmark tests the performance of five different ways to iterate over an array and perform calculations:

1. `forEach`
2. `reduce`
3. `map`
4. `filter`
5. A traditional `for` loop

All these methods are used in conjunction with a simple calculation function `someFn(i)` that takes an integer as input.

**What options are being compared?**

The benchmark is comparing the execution speed (measured in executions per second) of these five different iteration methods:

1. **forEach**: The `forEach` method iterates over an array and performs an operation on each item.
2. **reduce**: The `reduce` method applies a function to each element of an array, reducing it to a single value.
3. **map**: The `map` method creates a new array by applying a function to each element of the original array.
4. **filter**: The `filter` method creates a new array with all elements that pass a test implemented by a provided function.
5. **for**: A traditional `for` loop is used as a baseline for comparison.

**Pros and cons of these approaches:**

* **forEach**:
	+ Pros: Easy to use, concise code.
	+ Cons: May have performance issues with large datasets (although this benchmark suggests it's not the case).
* **reduce**:
	+ Pros: Can be used to accumulate values or reduce an array to a single value.
	+ Cons: May require more mental effort to understand the callback function's purpose.
* **map**:
	+ Pros: Creates a new array with transformed values, which can be useful for data processing.
	+ Cons: May create unnecessary memory usage if not properly handled.
* **filter**:
	+ Pros: Easy to use and concise code, useful for filtering out unwanted elements.
	+ Cons: May have performance issues with large datasets (although this benchmark suggests it's not the case).
* **for**: Traditional loops are often faster and more predictable in terms of performance.

**Library usage:**

No specific library is used in these test cases. The calculations are performed using basic JavaScript arithmetic operations.

**Special JS feature or syntax:**

The `forEach`, `reduce`, `map`, and `filter` methods are all part of the standard JavaScript API (ECMAScript 5+).

**Other alternatives:**

If you need to iterate over an array and perform calculations, consider using:

1. **for...of**: A more modern, readable way to iterate over iterables.
2. **while**: If you need fine-grained control over iteration, a traditional `while` loop can be used.

Keep in mind that these alternatives may not be the best choice for every scenario. The choice of method depends on your specific use case and personal preference.

Related benchmarks:

forEach vs reduce vs map vs filter vs for (slightly optimized for) (version: 0)

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

Created: 5 years ago by: Guest

Jump to the latest result

forEach

reduce

map

filter

for

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model llama3.1:latest, generated one year ago):