Benchmark: Merging Objects - MeasureThat.net

Script Preparation code:

function createSlices(numSlices, propsPerSlice = 5) {
  const arr = [];

  for (let i = 0; i < numSlices; i++) {
    const o = {};
    for (let j = 0; j < propsPerSlice; j++) {
      o[`key_${i}_${j}`] = `${i}_${j}`;
    }
    arr.push(o);
  }

  return arr;
}

var slices = createSlices(100);

Tests:

Reduce / Spread
slices.reduce((store, slice) => ({ ...store, ...slice }), {});
Assign / Single spread
Object.assign({}, ...slices);
fromEntries / Entries
Object.fromEntries( slices .map((slice) => Object.entries(slice)) .flat() );
Assign / Mutate first obj
slices.unshift({}); Object.assign(...slices);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce / Spread
Assign / Single spread
fromEntries / Entries
Assign / Mutate first obj

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is designed to measure the performance of different methods for merging objects in JavaScript. The script preparation code generates an array of 100 objects, each with 5 properties.

**Options Compared**

There are four test cases:

1. **Reduce / Spread**: Using `Array.prototype.reduce()` and the spread operator (`...`) to merge objects.
2. **Assign / Single spread**: Using `Object.assign()` with a single object as an argument (i.e., spreading an array of objects onto a target object).
3. **fromEntries / Entries**: Using `Object.fromEntries()` with an array of key-value pairs.
4. **Assign / Mutate first obj**: Using `Array.prototype.unshift()` to add an empty object at the beginning of the array, followed by `Object.assign()` to merge the objects.

**Pros and Cons**

*   **Reduce / Spread**: This approach is concise and easy to read. It uses a single function call to merge all objects into a single result.
    *   Pros: Efficient, readable
    *   Cons: Can be slower than other approaches if the input array is large.
*   **Assign / Single spread**: Using `Object.assign()` with an array of objects as arguments can be more efficient than using `reduce()` or `fromEntries()`.
    *   Pros: Fast for small to medium-sized arrays, concise
    *   Cons: Can lead to slower performance if the input array is large.
*   **fromEntries / Entries**: This approach uses a modern syntax to merge objects from an array of key-value pairs. It can be more efficient than other approaches when working with large datasets.
    *   Pros: Fast for large arrays, concise
    *   Cons: Less intuitive than other approaches
*   **Assign / Mutate first obj**: Adding an empty object at the beginning of the array and then merging it with `Object.assign()` can be less efficient than using one of the above methods.
    *   Pros: None notable
    *   Cons: Can lead to slower performance due to unnecessary object creation

**Library**

None mentioned in this benchmark.

**Special JS Features or Syntax**

The benchmark uses modern JavaScript syntax and features, such as:

*   Arrow functions (`=>`)
*   Spread operator (`...`)
*   `Object.fromEntries()` and `Array.prototype.flatMap()`
*   Template literals (`${}`)

These features are widely supported by modern browsers and engines.

**Other Alternatives**

Some alternative methods for merging objects could be considered, such as:

*   Using a library like Lodash's `merge` function
*   Implementing a custom merge function using recursion or iteration
*   Using a more functional programming approach with `reduce()` or `map()`

However, the benchmark is focused on comparing the performance of specific methods and syntaxes that are commonly used in JavaScript development.

Latest run results:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 93 on Mac OS X 10.13.6

View result in a separate tab

Test name	Executions per second
Reduce / Spread	350.4 Ops/sec
Assign / Single spread	15291.2 Ops/sec
fromEntries / Entries	4875.3 Ops/sec
Assign / Mutate first obj	24640.4 Ops/sec

Related benchmarks:

Merging Objects (version: 8)

Comparing performance of: Reduce / Spread vs Assign / Single spread vs fromEntries / Entries vs Assign / Mutate first obj

Created: 3 years ago by: Registered User

Jump to the latest result

Reduce / Spread

Assign / Single spread

fromEntries / Entries

Assign / Mutate first obj

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):