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

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 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.

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: 4 years ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

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