Benchmark: forEach vs reduce vs map vs filter vs for (better 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 (var 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.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided benchmark compares the performance of five different approaches to iterate over an array: `forEach`, `reduce`, `map`, `filter`, and a traditional `for` loop. The goal is to determine which approach is most efficient.

**Approaches Compared**

1. **`forEach`**: Iterates over the array using the `forEach` method, which calls a callback function for each element in the array.
2. **`reduce`**: Accumulates a value by repeatedly applying a reducer function to an accumulator and each element in the array.
3. **`map`**: Creates a new array with the results of applying a transformation function to each element in the original array.
4. **`filter`**: Creates a new array with all elements that pass the test implemented by a provided function.
5. **Traditional `for` loop**: Iterates over the array using a traditional `for` loop, which is not as concise but provides more control.

**Pros and Cons of Each Approach**

1. **`forEach`**:
	* Pros: Easy to read and write, concise syntax.
	* Cons: May incur additional overhead due to method call and callback function execution.
2. **`reduce`**:
	* Pros: Can accumulate values efficiently, provides a clear accumulator.
	* Cons: May be slower than other approaches due to the repeated function calls.
3. **`map`**:
	* Pros: Creates a new array with transformed elements, can be efficient for large datasets.
	* Cons: Requires more memory allocation and copying of data.
4. **Traditional `for` loop**:
	* Pros: Provides direct access to array elements, no overhead from method calls or callback functions.
	* Cons: More verbose and less readable than other approaches.

**Special Features**

The benchmark uses a custom function `someFn(i)` that performs a complex calculation involving multiplication and division. This function is used to generate the values for each element in the array.

**Library Used**

None, this benchmark only relies on built-in JavaScript features and the provided script preparation code.

**Other Considerations**

When choosing an iteration approach, consider the following factors:

* Performance: If you need to iterate over a large dataset, `reduce` or traditional `for` loops might be more efficient.
* Code readability: `forEach`, `map`, and `filter` provide concise syntax and are easier to read for simple use cases.
* Memory allocation: `map` may incur additional memory allocation due to the creation of a new array.

**Alternatives**

Other iteration approaches not compared in this benchmark include:

* `for...of`: A more modern alternative to traditional `for` loops, which provides better support for iterable objects.
* `Array.prototype.forEach.call()`: An older version of the `forEach` method that can be used as a callback function.
* Higher-order functions like `every()`, `some()`, and `includes()`.

Keep in mind that the choice of iteration approach depends on your specific use case, dataset size, and performance requirements.

Related benchmarks:

forEach vs reduce vs map vs filter vs for (better for) (version: 0)

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

Created: 6 years ago by: Registered User

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.2:3b, generated one year ago):