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

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) => { acc[curr.id] = curr; return acc; })
From Entries
Object.assign( {}, ...users.map(k => ({ [k.id]: k, })), );

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce
From Entries

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's being tested.

**Benchmark Overview**

The benchmark is designed to compare the performance of three different approaches for adding properties to an object: `Array.prototype.reduce()`, `Object.assign()`, and `Object.fromEntries()`.

**Options Compared**

The two main options compared are:

1. **`Array.prototype.reduce()`**: This method applies a function to each element in an array, reducing it to a single output value.
2. **`Object.assign()`**: This method copies all enumerable own properties from one or more source objects to a target object.

**Pros and Cons**

* `Array.prototype.reduce()`: Pros:
	+ Can be used to add properties to an object.
	+ Returns the modified object.
	Cons:
	+ Requires creating an accumulator object, which can lead to memory issues for large inputs.
	+ May not be as efficient as other methods due to its functional programming nature.
* `Object.assign()`**: Pros:
	+ Easy to use and intuitive.
	+ Returns the modified object.
	Cons:
	+ Can be slower than other methods due to the need to create multiple copies of objects.
	+ Limited control over property addition.

**Object.fromEntries()**

This method was introduced in ECMAScript 2015 (ES6) as a modern alternative to `Array.prototype.reduce()` and `Object.assign()`. It creates an object from an iterable of key-value pairs.

Pros:

* More concise and readable than `Array.prototype.reduce()` or `Object.assign()`.
* Can be faster due to its optimized implementation.
Cons:

* May not be supported in older browsers or environments.

**Library**

None are used explicitly in this benchmark. However, the benchmark assumes that the `Array` object and `Object` object are available.

**Special JS Feature/Syntax**

The benchmark uses ES6 syntax for `Object.fromEntries()` and ES6 arrow functions for callback functions (`users.reduce()`). These features were introduced in ECMAScript 2015 (ES6) and are widely supported in modern browsers.

**Other Alternatives**

If you want to add properties to an object, other alternatives exist:

* Using a `for...in` loop: This method is similar to `Object.assign()`, but it doesn't create copies of objects.
* Using the spread operator (`{ ...obj }`): This method creates a shallow copy of an object and adds new properties.
* Using a library like Lodash's `_.extend()` function.

Keep in mind that these alternatives may have different performance characteristics compared to the methods being tested in this benchmark.

Related benchmarks:

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

Comparing performance of: Reduce vs From Entries

Created: 3 years ago by: Guest

Jump to the latest result

Reduce

From Entries

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