Benchmark: Reduce and Spread vs. Foreach and Mutate (fewer, but larger, objects)

Script Preparation code:

var objectsArray = Array(10).fill(() => {
  return Object.fromEntries(Array(100).fill(() => {
    const key = Math.random().toString(36).substring(2, 5);
    const value = Math.random().toString(36).substring(2, 5);
    return [key, value];
  }));
});

Tests:

Reduce and Spread
var combined = objectsArray.reduce((memo, obj) => ({...memo, ...obj}), {});
ForEach and Mutate (for .. in loop)
var combined = {} objectsArray.forEach(obj => { for (const key in obj) { combined[key] = obj[key]; } });
Mutate with Object.assign
var combined = Object.assign(...objectsArray)
Foreach and Mutate (Object.assign)
var combined = {} objectsArray.forEach(obj => Object.assign(combined, obj));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce and Spread
ForEach and Mutate (for .. in loop)
Mutate with Object.assign
Foreach and Mutate (Object.assign)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/132.0.6834.78 Mobile/15E148 Safari/604.1

Browser/OS: Chrome Mobile iOS 132 on iOS 18.2.1

View result in a separate tab

Mutate with Object.assign

1.7M/s

Foreach and Mutate (Object.assign)

1.5M/s

Reduce and Spread

1.2M/s

ForEach and Mutate (for .. in loop)

1.1M/s

View exact numbers

Test name	Executions per second
✓ Mutate with Object.assign	1,723,426 Ops/sec
Foreach and Mutate (Object.assign)	1,511,515 Ops/sec
Reduce and Spread	1,175,197 Ops/sec
ForEach and Mutate (for .. in loop)	1,089,860 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 world of JavaScript microbenchmarks!

**Benchmark Overview**

The provided benchmark compares four different approaches to merge multiple objects in JavaScript:

1. `Reduce` with spread operator (`...`)
2. `ForEach` loop with mutation using `key`-`value` pairs
3. `Mutate` using `Object.assign()`
4. `ForEach` loop with object assignment using `Object.assign()` method

**Options Compared**

The benchmark tests the performance of each approach on a large dataset of 10 objects, each containing 100 randomly generated key-value pairs.

* **Reduce**: uses the `reduce()` method to merge objects by spreading their properties into a single object.
* **ForEach loop with mutation**: uses a `for...in` loop to iterate over the object's properties and assign values to a new object using bracket notation (`combined[key] = obj[key];`).
* **Mutate with Object.assign()**: uses the `Object.assign()` method to merge objects by copying their properties into a single object.
* **ForEach loop with Object.assign()**: similar to the previous approach, but uses the `Object.assign()` method to assign values from one object to another.

**Pros and Cons**

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

1. **Reduce**: Pros: concise, efficient; Cons: may not be as readable for complex datasets.
2. **ForEach loop with mutation**: Pros: flexible, can handle nested objects; Cons: slower due to iteration and bracket notation.
3. **Mutate with Object.assign()**: Pros: simple, reliable; Cons: assumes a specific object structure (e.g., all properties are enumerable).
4. **ForEach loop with Object.assign()**: Pros: readable, avoids mutation issues; Cons: may be slower due to repeated method calls.

**Library Usage**

The benchmark uses `Object.fromEntries()` and `Array.prototype.fill()` which are part of the ECMAScript standard (ES6). No external libraries are required.

**Special JS Features/Syntax**

None mentioned in the provided code snippet. However, it's worth noting that modern JavaScript engines often use various optimizations, such as just-in-time compilation, caching, or parallel execution, which can affect benchmark results.

**Other Alternatives**

If you're interested in exploring other approaches, consider the following alternatives:

1. `Array.prototype.reduce()` with a callback function to merge objects.
2. Using a library like Lodash (which provides `merge` and `assignInPlace` functions) for more complex object merging.
3. Employing a library like Ramda (which offers `mergeBy` and `mapValues` functions) for functional programming approaches.

Please keep in mind that the best approach will depend on your specific use case, data structure, and performance requirements.

Reduce and Spread vs. Foreach and Mutate (fewer, but larger, objects) (version: 0)

Comparing performance of: `Reduce and Spread vs ForEach and Mutate (for .. in loop) vs Mutate with Object.assign vs Foreach and Mutate (Object.assign)`

Created: 6 years ago by: Guest

Go to the latest result

Reduce and Spread

ForEach and Mutate (for .. in loop)

Mutate with Object.assign

Foreach and Mutate (Object.assign)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Reduce and Spread vs. Foreach and Mutate (fewer, but larger, objects) (version: 0)

Comparing performance of: Reduce and Spread vs ForEach and Mutate (for .. in loop) vs Mutate with Object.assign vs Foreach and Mutate (Object.assign)

Created: 6 years ago by: Guest

Go to the latest result

Reduce and Spread

ForEach and Mutate (for .. in loop)

Mutate with Object.assign

Foreach and Mutate (Object.assign)

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: `Reduce and Spread vs ForEach and Mutate (for .. in loop) vs Mutate with Object.assign vs Foreach and Mutate (Object.assign)`