Benchmark: Reduce vs Object.assign vs Object.fromEntries vs Object.assign v2

Script Preparation code:

function createArray(propsCount) {
    const arr = []
    for (let i = 0; i < propsCount; i += 1) {
        arr.push({
            active: i % 5 === 0
        })
    }
    return arr
}

var users = createArray(1000)

Tests:

Reduce
users.reduce((acc, curr) => { if (curr.active) { return acc } return { ...acc, [curr.id]: curr.name } })
Map Filter Reduce Assign
users.filter((user) => !user.active).map((user) => ({ [user.id]: user.name })).reduce(Object.assign, {})
From Entries
Object.fromEntries(users.filter((user) => !user.active).map((user) => [user.id, user.name]))
Trivial reduce
users.filter((user) => !user.active).reduce((acc, {id, name}) => Object.assign(acc, { [id]: name }), {})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce
Map Filter Reduce Assign
From Entries
Trivial reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Linux

View result in a separate tab

From Entries

10K/s

Reduce

9K/s

Trivial reduce

6K/s

Map Filter Reduce Assign

8/s

View exact numbers

Test name	Executions per second
✓ From Entries	10,029 Ops/sec
Reduce	9,168 Ops/sec
Trivial reduce	5,674 Ops/sec
Map Filter Reduce Assign	8 Ops/sec

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 is being tested.

**Benchmark Overview**

The benchmark compares the performance of four different approaches to merge an object with dynamic keys:

1. `Object.assign()`
2. `Object.fromEntries()`
3. `reduce()` (with a callback function)
4. `trivial reduce` (using a modified version of `reduce()`)

**Options Compared**

Each approach is being tested on the same input data, which consists of an array of objects with dynamic keys (`id` and `name`). The test aims to measure the performance difference between these four approaches.

**Pros and Cons of Each Approach**

1. **Object.assign()**:
	* Pros: Simple and widely supported.
	* Cons: May lead to shallow copying, which can result in unexpected behavior if the input object has complex inheritance structures.
2. **Object.fromEntries()**:
	* Pros: Modern and efficient, creates a new object with the desired structure.
	* Cons: Introduced in ECMAScript 2015, not supported by older browsers. Requires the `entries()` method to be available.
3. **Reduce()` (with a callback function):
	* Pros: Flexible and can handle complex merge scenarios.
	* Cons: May lead to slower performance due to the overhead of iterating over the input array.
4. **Trivial reduce**:
	* Pros: Optimized version of `reduce()`, avoids unnecessary iterations.
	* Cons: Requires a custom implementation, which may not be familiar to all developers.

**Library and Special JS Features**

None of the test cases uses specific libraries or advanced JavaScript features like Web Workers or async/await. The focus is on the core object manipulation functions.

**Other Considerations**

When evaluating this benchmark, consider the following:

* **Browser support**: As `Object.fromEntries()` was introduced in ECMAScript 2015, older browsers might not support it.
* **Input data size**: The test case uses a large array of objects (1000 elements). You may want to run the benchmark with smaller input sizes to isolate the performance differences between approaches.
* **Contextual factors**: This benchmark focuses on the core object manipulation functions. Consider running additional tests to evaluate other aspects, such as caching or optimization strategies.

**Alternatives**

If you're looking for alternative approaches or want to explore more advanced techniques:

1. Use a library like Lodash, which provides optimized and flexible merge functions.
2. Implement a custom merge function using `reduce()` with a clever implementation.
3. Consider using `Array.prototype.reduce()` with a binary search approach to optimize performance.

Keep in mind that the choice of approach depends on your specific use case, requirements, and target browser support.

Reduce vs Object.assign vs Object.fromEntries vs Object.assign v2 (version: 0)

Comparing performance of: `Reduce vs Map Filter Reduce Assign vs From Entries vs Trivial reduce`

Created: one year ago by: Guest

Go to the latest result

Reduce

Map Filter Reduce Assign

From Entries

Trivial reduce

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Reduce vs Object.assign vs Object.fromEntries vs Object.assign v2 (version: 0)

Comparing performance of: Reduce vs Map Filter Reduce Assign vs From Entries vs Trivial reduce

Created: one year ago by: Guest

Go to the latest result

Reduce

Map Filter Reduce Assign

From Entries

Trivial reduce

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 vs Map Filter Reduce Assign vs From Entries vs Trivial reduce`