Benchmark: forEach vs reduce vs map vs filter vs for vs lodash

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

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]; }
lodash map
_.map(arr, (item) => sumMap += someFn(item));
lodash filter
_.filter(arr, (item) => (sumFilter += someFn(item)));
lodash foreach
_.forEach(arr, (item) => sumForEach += someFn(item));
lodash reduce
_.reduce(arr, (lastValue, item) => { return sumReduce += someFn(item); });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
reduce
map
filter
for
lodash map
lodash filter
lodash foreach
lodash reduce

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 months ago)

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

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
forEach	869.0 Ops/sec
reduce	894.7 Ops/sec
map	890.0 Ops/sec
filter	869.8 Ops/sec
for	1056.9 Ops/sec
lodash map	669.6 Ops/sec
lodash filter	802.1 Ops/sec
lodash foreach	477.6 Ops/sec
lodash reduce	609.9 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The provided JSON represents a benchmarking test created on MeasureThat.net. The goal is to compare the performance of various iteration methods in JavaScript: `forEach`, `reduce`, `map`, `filter`, and `for`. Additionally, two implementations using the popular utility library Lodash (`lodash`) are included.

**Iteration Methods Compared**

1. **`forEach`**: Iterates over an array using a callback function.
2. **`reduce`**: Accumulates values by iteratively applying a callback function to each element in the array.
3. **`map`**: Creates a new array with the results of applying a callback function to each element in the original array.
4. **`filter`**: Creates a new array with only the elements that pass the test implemented by the provided callback function.
5. **`for`**: Uses a traditional `for` loop to iterate over an array.

**Lodash Implementations**

1. **`lodash map`**: Uses Lodash's `map` function to create a new array with transformed values.
2. **`lodash filter`**: Uses Lodash's `filter` function to create a new array with filtered values.
3. **`lodash foreach`**: Uses Lodash's `forEach` function (which is similar to the native `forEach`) to iterate over an array.

**Performance Analysis**

The benchmark results show that:

* The Lodash implementations (`map`, `filter`, and `foreach`) are significantly faster than the native iteration methods (`forEach`, `reduce`, and `for`).
* Within the native iteration methods, `map` is generally the fastest followed by `reduce`.
* `for` is the slowest due to its traditional loop structure.

**Key Takeaways**

1. **Lodash can improve performance**: Using Lodash's optimized functions (`map`, `filter`, and `foreach`) can significantly reduce iteration times.
2. **Native iteration methods have trade-offs**: While `forEach` and `reduce` are more concise, they may not be as efficient as the native loop structure in some cases.
3. **Performance optimization is crucial**: Understanding the performance characteristics of different iteration methods is essential for optimizing code that processes large datasets.

By considering these insights, you can write more efficient JavaScript code that takes advantage of optimized functions and clever iteration techniques.

Related benchmarks:

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

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

Created: 5 years ago by: Registered User

Jump to the latest result

forEach

reduce

map

filter

for

lodash map

lodash filter

lodash foreach

lodash reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):