Benchmark: Create New Object from Reduce vs. ForEach vs For vs Object.entries

Create New Object from Reduce vs. ForEach vs For vs Object.entries (version: 4)

Comparing performance of: Populate object via ForEach vs Populate object via Reduce vs Populate object via Reduce (optimized) vs Populate object via For ... Of vs Populate object via Object.entries (for of) vs Populate object via Object.entries (foreach)

Created: 2 years ago by: Registered User

Jump to the latest result

Script Preparation code:

var objects = Array.from(new Array(2000)).map((r, i) => ({
  id: `id-${i}`,
  propA: Array.from(new Array(20000)).map((r, i) => ({ nested: i })),
  propB: Array.from(new Array(20000)),
}));

Tests:

Populate object via ForEach
var newMapFE = {}; objects.forEach(o => { newMapFE[o.id] = o.val })
Populate object via Reduce
objects.reduce((acc, item) => ({...acc, [item.id]: item.val}), {});
Populate object via Reduce (optimized)
objects.reduce((acc, item) => { acc[item.id] = item.val; return acc; }, {});
Populate object via For ... Of
var newMapFE = {}; for (obj in objects) { newMapFE[obj.id] = obj.val }
Populate object via Object.entries (for of)
var newMapFE = {}; for (const [key, value] of Object.entries(objects)) { newMapFE[key] = value; }
Populate object via Object.entries (foreach)
var newMapFE = {}; Object.entries(objects).forEach(([key, value]) => { newMapFE[key] = value; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Populate object via ForEach
Populate object via Reduce
Populate object via Reduce (optimized)
Populate object via For ... Of
Populate object via Object.entries (for of)
Populate object via Object.entries (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 provided benchmark and explain what each option is testing, their pros and cons, and other considerations.

**Benchmark Definition**

The benchmark defines four options to populate an object from an array of objects:

1. `ForEach`: Using `forEach` loop to iterate over the array and assign values to the object.
2. `Reduce`: Using `reduce` method to accumulate values in a new object.
3. `Reduce (optimized)`: A variation of `Reduce` that avoids cloning the accumulator object.
4. `For...Of`: Using `for...of` loop with `Object.entries` to iterate over the array and assign values to the object.

**Options Comparison**

Here's a brief overview of each option:

### ForEach

* **Pros**: Simple, straightforward approach. Fast execution speed due to native implementation.
* **Cons**: Iterating over the array using `forEach` can lead to slower performance compared to other methods, as it involves an additional loop overhead.

### Reduce

* **Pros**: More efficient than `ForEach`, especially for large datasets, since it uses a single loop and avoids cloning the accumulator object.
* **Cons**: Cloning the accumulator object during each iteration, which can be costly for large objects. The optimization provided by the `Reduce (optimized)` variant helps mitigate this issue.

### Reduce (optimized)

* **Pros**: A variation of `Reduce` that avoids cloning the accumulator object, resulting in faster execution speed and reduced memory allocation.
* **Cons**: May require careful implementation to ensure proper accumulation of values, as the optimizer relies on the programmer's understanding of the loop structure.

### For...Of

* **Pros**: Modern JavaScript feature that provides a concise way to iterate over arrays. Fast execution speed due to native implementation.
* **Cons**: Not supported in older browsers or environments. Can be less readable for those unfamiliar with the syntax.

**Other Considerations**

* The `Object.entries` method is used in two of the options (`For...Of` and `Object.entries (foreach)`). This method provides a convenient way to iterate over an object's key-value pairs.
* The use of `Array.from` is common among these options, which creates a new array from an iterable source.

**Libraries**

None of the provided benchmark options rely on external libraries. However, if you're interested in exploring alternative methods that utilize external libraries or frameworks, here are some examples:

* For a faster `Reduce` implementation, consider using a library like Lodash's `reduceBy`.
* For parallel processing and optimization, explore libraries like worker threads (e.g., `worker_threads`) or parallel-processing frameworks like Node.js's built-in ` cluster` module.

Keep in mind that these alternatives may introduce additional complexity and overhead.

Related benchmarks: