Benchmark: lodash - reduce vs forEach with large array to object

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 < 1000000; i++) {
  arr.push(i);
}

Tests:

reduce
var results = _.reduce(arr, (results, result) => { let key = `a_${result}_b_${result}_c`; results[key] = results[key] || key; return results; });
forEach
var results = {}; _.each(arr, (result) => { let key = `a_${result}_b_${result}_c`; results[key] = results[key] || key; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
forEach

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 break down the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of two approaches: using `_.reduce()` from the Lodash library and using `_.forEach()` to achieve the same result. The test creates an array with 1 million elements, populates it with numbers, and then uses each approach to transform the array into an object where each key is a unique identifier composed of three parts.

**Options Compared**

Two options are compared:

1. **`.reduce()`**: This method applies a function to each element in the array, accumulating a result. In this case, it's used to create an object where each key is a unique identifier.
2. **`.forEach()`**: This method calls a provided callback function once for each element in the array.

**Pros and Cons of Each Approach**

* `_.reduce()`:
	+ Pros:
		- More concise and expressive code
		- Can be more efficient if the accumulator is not needed, as it avoids creating an intermediate object.
	+ Cons:
		- May be slower due to the overhead of creating an intermediate array or object.
		- Less intuitive for developers who are not familiar with functional programming concepts.
* `_.forEach()`:
	+ Pros:
		- More intuitive and easy to understand for developers familiar with traditional loops.
		- Can be faster if the callback function only needs to access the current element without accumulating a result.
	+ Cons:
		- Requires more code, which can make it less readable and maintainable.
		- May require additional operations to create the final object.

**Lodash Library**

The `_.reduce()` method is part of the Lodash library, which provides a collection of functional programming helpers. The `_.forEach()` method is also provided by Lodash, but it's not necessary for this specific benchmark since we're only using it as a comparison to `_.reduce()`.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntaxes used in this benchmark beyond what's standard for functional programming with Lodash. The focus is on comparing the performance of two different approaches to achieve the same result.

**Other Alternatives**

If you wanted to write a similar benchmark, you could consider using other libraries or implementing the solution from scratch. Some alternatives include:

* Using `Array.prototype.reduce()` instead of Lodash's `_.reduce()`
* Implementing a custom loop that uses `forEach` and manually creates the object
* Using a different library like Ramda or Underscore.js for the comparison

Keep in mind that benchmarking can be complex, and the choice of approach will depend on your specific use case and requirements.

Related benchmarks:

lodash - reduce vs forEach with large array to object (version: 0)

Comparing performance of: reduce vs forEach

Created: 3 years ago by: Guest

Jump to the latest result

reduce

forEach

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