Benchmark: forEach vs reduce vs map vs filter vs 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; j < arr.length; j++) { sumFor += arr[j]; }

Historical Performance Data aggregated from 565 community runs

Desktop Results:

Chrome 419 runs

forEach

562/s

reduce

555/s

map

522/s

filter

514/s

for

497/s

Fastest: forEach (1.1x faster)

View exact numbers

✓ forEach: 562 ops/sec
• reduce: 555 ops/sec
• map: 522 ops/sec
• filter: 514 ops/sec
• for: 497 ops/sec

Firefox 82 runs

for

7K/s

forEach

6K/s

reduce

5K/s

map

5K/s

filter

5K/s

Fastest: for (1.4x faster)

View exact numbers

✓ for: 6,501 ops/sec
• forEach: 5,547 ops/sec
• reduce: 5,476 ops/sec
• map: 4,892 ops/sec
• filter: 4,713 ops/sec

Safari 16 runs

forEach

720/s

for

571/s

reduce

570/s

filter

531/s

map

412/s

Fastest: forEach (1.7x faster)

View exact numbers

✓ forEach: 720 ops/sec
• for: 571 ops/sec
• reduce: 570 ops/sec
• filter: 531 ops/sec
• map: 412 ops/sec

Other 10 runs

forEach

528/s

reduce

527/s

map

526/s

filter

509/s

for

460/s

Fastest: forEach (1.1x faster)

View exact numbers

✓ forEach: 528 ops/sec
• reduce: 527 ops/sec
• map: 526 ops/sec
• filter: 509 ops/sec
• for: 460 ops/sec

Mobile Results:

Chrome 22 runs

reduce

256/s

forEach

241/s

map

237/s

filter

229/s

for

226/s

Fastest: reduce (1.1x faster)

View exact numbers

✓ reduce: 256 ops/sec
• forEach: 241 ops/sec
• map: 237 ops/sec
• filter: 229 ops/sec
• for: 226 ops/sec

Safari 11 runs

forEach

925/s

reduce

845/s

map

843/s

filter

806/s

for

640/s

Fastest: forEach (1.4x faster)

View exact numbers

✓ forEach: 925 ops/sec
• reduce: 845 ops/sec
• map: 843 ops/sec
• filter: 806 ops/sec
• for: 640 ops/sec

Firefox 5 runs

for

2K/s

forEach

2K/s

reduce

2K/s

map

2K/s

filter

2K/s

Fastest: for (1.5x faster)

View exact numbers

✓ for: 2,418 ops/sec
• forEach: 1,926 ops/sec
• reduce: 1,883 ops/sec
• map: 1,724 ops/sec
• filter: 1,598 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: 17 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:152.0) Gecko/20100101 Firefox/152.0

Browser/OS: Firefox 152 on Windows

View result in a separate tab

for

25K/s

reduce

16K/s

forEach

14K/s

filter

11K/s

map

11K/s

View exact numbers

Test name	Executions per second
✓ for	24,731 Ops/sec
reduce	16,042 Ops/sec
forEach	13,770 Ops/sec
filter	11,401 Ops/sec
map	10,670 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided JSON data and its associated benchmark.

**Benchmark Definition**

The benchmark is designed to compare the performance of four different approaches for iterating over an array: `forEach`, `reduce`, `map`, and `filter`. The script prepares an array of 12345 elements, each with a specific calculation performed on it. The common function, `someFn(i)`, is applied to each element.

**Options Compared**

The benchmark compares the performance of four different iteration methods:

1. **`forEach`**: Iterates over the array using the `forEach` method, applying the common function to each element.
2. **`reduce`**: Iterates over the array using the `reduce` method, accumulating the results of the common function for all elements.
3. **`map`**: Iterates over the array using the `map` method, creating a new array with the result of applying the common function to each element.
4. **`filter`**: Iterates over the array using the `filter` method, creating a new array with only the elements for which the common function returns true.

**Pros and Cons**

Here's a brief overview of the pros and cons of each approach:

* **`forEach`**:
	+ Pros: Simple to implement, suitable for iterative operations.
	+ Cons: May not be as efficient as other methods due to the need for explicit looping.
* **`reduce`**:
	+ Pros: Efficiently accumulates results, suitable for aggregating data.
	+ Cons: Can be less readable than other methods, requires careful handling of initial values.
* **`map`**:
	+ Pros: Creates a new array with transformed data, suitable for operations that require multiple outputs.
	+ Cons: May create unnecessary memory allocation and copying.
* **`filter`**:
	+ Pros: Efficiently removes unwanted elements, suitable for filtering data.
	+ Cons: Can be slower than other methods due to the need for conditional checks.

**Library and Purpose**

In this benchmark, no external libraries are used. However, if we consider the common function `someFn(i)` as a utility library, its purpose is to perform a complex calculation on each array element.

**Special JS Feature or Syntax**

This benchmark does not explicitly use any special JavaScript features or syntax beyond the standard iteration methods. If you're interested in exploring more advanced techniques, you could consider using other libraries like Lodash or Ramda, which provide additional functional programming utilities.

**Other Alternatives**

If you'd like to explore alternative approaches for iterating over arrays, here are a few options:

1. **Using `for` loops**: A basic iterative approach that can be optimized with caching and loop unrolling.
2. **Using `Array.prototype.every()`**: An alternative filtering method that checks all elements in the array.
3. **Using `Array.prototype.some()`**: Another filtering method that checks at least one element in the array.

Keep in mind that these alternatives might not offer significant performance benefits over the original methods and may introduce additional complexity.

I hope this explanation helps you understand the benchmark and its associated options!

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

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

Created: 8 years ago by: Guest

Go to the latest result

forEach

reduce

map

filter

for

Historical Performance Data aggregated from 565 community runs

Desktop Results:

Chrome 419 runs

Firefox 82 runs

Safari 16 runs

Other 10 runs

Mobile Results:

Chrome 22 runs

Safari 11 runs

Firefox 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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

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

Created: 8 years ago by: Guest

Go to the latest result

forEach

reduce

map

filter

for

Historical Performance Data aggregated from 565 community runs

Desktop Results:

Chrome 419 runs

Firefox 82 runs

Safari 16 runs

Other 10 runs

Mobile Results:

Chrome 22 runs

Safari 11 runs

Firefox 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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