Benchmark: reduce vs foreach with destructuring and without

Script Preparation code:

var data = [];
for (var iterator = 0; iterator < 1000; iterator++) {
	data.push({id: iterator, name: 'Iteration ' + iterator});
}

Tests:

Reduce
var flattened = data.reduce((entities, item) => { return { ...entities, [item.id]: item } }, {}); console.log(flattened);
Foreach
var flattened = {}; data.forEach((item) => { flattened[item.id] = item; }); console.log(flattened);
Reduce but without destructuring
var flattened = data.reduce((entities, item) => { entities[item.id] = item; return entities; }, {}); console.log(flattened);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce
Foreach
Reduce but without destructuring

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 Definition:**
The website provides a JSON representation of a JavaScript microbenchmark, which allows users to compare different approaches to achieving the same result. The benchmark is designed to test the performance of two loops: `reduce` and `forEach`.

**Options Compared:**

1. **Reduce:** This option uses the `reduce()` method to transform the array into an object with flattened properties.
2. **Foreach:** This option uses a traditional `forEach` loop to iterate over the array and populate the `flattened` object.

**Pros and Cons of Each Approach:**

1. **Reduce:**
	* Pros:
		+ Can be more memory-efficient, as it only creates a single object to store the result.
		+ Often considered more concise and expressive, as it uses a single method to achieve the desired outcome.
	* Cons:
		+ Can be slower due to the overhead of creating an initial value for the accumulator (in this case, an empty object `{}`).
2. **Foreach:**
	* Pros:
		+ Typically faster, as it avoids the overhead of creating an accumulator object.
	* Cons:
		+ Often requires more code and is less concise, as you need to explicitly create and populate the `flattened` object.

**Library Usage:**
There is no explicit library mentioned in this benchmark. However, the `reduce()` method is a built-in JavaScript function that's part of the ECMAScript standard.

**Special JS Features/Syntax:**
This benchmark does not rely on any special JavaScript features or syntax beyond what's considered "standard" by the time of its writing (ES6+).

Related benchmarks:

reduce vs foreach with destructuring and without (version: 0)

Comparing performance of: Reduce vs Foreach vs Reduce but without destructuring

Created: 5 years ago by: Guest

Jump to the latest result

Reduce

Foreach

Reduce but without destructuring

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