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

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 += someFn(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

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark test case on the MeasureThat.net website. The benchmark compares the performance of four different approaches: `forEach`, `reduce`, `map`, and `filter`. Additionally, an optimized version of a traditional `for` loop is also included for comparison.

**Approaches Compared**

1. **forEach**: This approach uses the `Array.prototype.forEach()` method to iterate over the array and accumulate the sum.
2. **reduce**: This approach uses the `Array.prototype.reduce()` method to iterate over the array and accumulate the sum.
3. **map**: This approach uses the `Array.prototype.map()` method to create a new array with the transformed values, but returns `undefined`, so we need to add a null check before accumulating the sum.
4. **filter**: This approach uses the `Array.prototype.filter()` method to create a new array with only the elements that pass the test, and then iterates over it to accumulate the sum.
5. **for (slightly optimized for) FORK**: This is an optimized version of a traditional `for` loop that uses a forked loop to improve performance.

**Pros and Cons**

1. **forEach**:
	* Pros: Easy to understand, simple syntax.
	* Cons: May have slower performance due to the overhead of calling the callback function on each iteration.
2. **reduce**:
	* Pros: Can be more efficient than `forEach` as it avoids the overhead of callback functions and uses a single loop.
	* Cons: Requires initial value for accumulator, may have slower performance if not optimized correctly.
3. **map**:
	* Pros: Allows transformation of values, can be useful in certain scenarios.
	* Cons: Returns an array, which can lead to extra memory allocation and garbage collection overhead.
4. **filter**:
	* Pros: Can be efficient if the filtering condition is simple, reduces the number of iterations.
	* Cons: May have slower performance due to the creation of a new array, and may use more memory.
5. **for (slightly optimized for) FORK**: This approach is optimized for performance by using a forked loop, but its implementation details are not specified.

**Library Used**

In this benchmark, no libraries are explicitly mentioned, except that MeasureThat.net itself uses some underlying technologies like JavaScript engines and hardware-accelerated rendering. However, the specific library used to create the benchmark script is not provided.

**Special JS Feature/Syntax**

There are a few special features used in this benchmark:

* `for (slightly optimized for) FORK`: This is a custom optimization technique that uses a forked loop to improve performance.
* The use of `let` and `const` declarations, which were introduced in ECMAScript 2015.

**Other Alternatives**

If you're looking for alternatives to these approaches, here are a few options:

* For iteration: Consider using a generator function or an iterator to avoid creating unnecessary arrays.
* For filtering: Use the `Array.prototype.every()` method instead of `filter()`, which can be more efficient in some cases.
* For transformation: Use `map()` with a single arrow function that returns the transformed value.

Keep in mind that the performance differences between these approaches may vary depending on the specific use case, hardware, and JavaScript engine being used.

Latest run results:

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

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

Browser/OS: Chrome 89 on Mac OS X 10.15.6

View result in a separate tab

Test name	Executions per second
forEach	302.9 Ops/sec
reduce	298.8 Ops/sec
map	286.1 Ops/sec
filter	266.0 Ops/sec
for	210.8 Ops/sec

Related benchmarks:

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

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

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