Benchmark: Object.fromEntries vs reduce - convert Array to Object

Script Preparation code:

var data = Array.from(Array(10000).keys()).map(v => ({id: v.toString(), value: `val=${v}`}));

Tests:

Object.fromEntries
Object.fromEntries(data.map(({id, value}) => [id, value]));
Reduce (reuse object)
data.reduce((acc, {id, value}) => { acc[id] = value; return acc; }, {});
Reduce (creating temporary objects)
data.reduce((acc, {id, value}) => ({ ...acc, [id]: value }), {});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
Reduce (reuse object)
Reduce (creating temporary objects)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Purpose:**
The benchmark compares three approaches to convert an array of objects to a single object in JavaScript:

1. Using `Object.fromEntries` with a mapped array of key-value pairs.
2. Using `Array.prototype.reduce()` with an initial empty object, where each iteration adds a new property to the object.
3. Using `Array.prototype.reduce()` with an initial empty object, but creating a temporary object on each iteration.

**Options Compared:**

1. **Object.fromEntries**: A relatively modern JavaScript method introduced in ECMAScript 2017 (ES7) that allows converting arrays of key-value pairs to objects.
2. **Reduce (reuse object)**: This approach reuses the same object for all iterations, adding properties as needed.
3. **Reduce (creating temporary objects)**: In this variant, a new temporary object is created on each iteration.

**Pros and Cons:**

1. **Object.fromEntries**:
	* Pros: concise and expressive syntax, fast execution times due to its optimized implementation.
	* Cons: not widely supported in older browsers or Node.js versions.
2. **Reduce (reuse object)**:
	* Pros: generally faster than creating temporary objects, as it avoids the overhead of object creation and destruction.
	* Cons: may lead to memory leaks if not used carefully, especially with large datasets.
3. **Reduce (creating temporary objects)**:
	* Pros: simple implementation and no potential for memory leaks.
	* Cons: slower execution times due to the additional object creation and destruction.

**Library/Libraries Used:** None mentioned in the provided benchmark definition.

**Special JavaScript Features/Syntax:**
The benchmark uses modern JavaScript features:

1. **Template literals**: Used in the initial `data` array creation string (`"val=${v}"`).
2. **Arrow functions**: Used in some of the reduce function definitions (`({ id, value }) => { ... }`).

**Other Alternatives:**

1. For creating objects from arrays, you could use the spread operator (`{ ...array.map(item => item.id).map(id => ({ id })) }`) or the `Array.prototype.forEach()` method.
2. For reducing arrays to single values or objects, you might consider using `Array.prototype.reduce()`, but without reusing an object (as in the "Reuse object" variant).

Keep in mind that these alternatives might have different performance characteristics and use cases compared to the benchmark's approaches.

In summary, this benchmark helps developers understand the trade-offs between different methods for converting arrays of objects to single objects in JavaScript, highlighting the pros and cons of each approach.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36

Browser/OS: Chrome 99 on Windows

View result in a separate tab

Test name	Executions per second
Object.fromEntries	4581.0 Ops/sec
Reduce (reuse object)	7560.6 Ops/sec
Reduce (creating temporary objects)	52.2 Ops/sec

Related benchmarks:

Object.fromEntries vs reduce - convert Array to Object (version: 0)

Comparing performance of: Object.fromEntries vs Reduce (reuse object) vs Reduce (creating temporary objects)

Created: 2 years ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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