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

Script Preparation code:

var data = Array.from(Array(10000).keys()).map(v => ({id: v, 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.

The provided JSON represents a JavaScript benchmark test case, where the goal is to compare the performance of three approaches for converting an array into an object.

**Approaches being compared:**

1. **Object.fromEntries**: This method creates a new object from an iterable (in this case, an array) by mapping each key-value pair in the array to the object.
2. **Reduce (reuse object)**: In this approach, the reduce() method is used to iterate over the array and accumulate the values into an existing object. The `acc` variable is reused as the accumulator object for each iteration, creating a new object on the fly.
3. **Reduce (creating temporary objects)**: Similar to the previous approach, but instead of reusing the same accumulator object, a new object is created in memory for each iteration.

**Pros and cons of each approach:**

* **Object.fromEntries**: This method is concise and readable, but it may not be as efficient as the other two approaches since it creates a new object from scratch.
	+ Pros: Easy to understand, minimal memory allocation.
	+ Cons: May have higher overhead due to object creation.
* **Reduce (reuse object)**:
	+ Pros: Reuses the same accumulator object for all iterations, reducing memory allocation and potentially improving performance.
	+ Cons: Can lead to stack overflow errors if the object becomes too large or if there are many iterations.
* **Reduce (creating temporary objects)**:
	+ Pros: Creates a new object on each iteration, which can be beneficial for modern JavaScript engines that optimize object creation.
	+ Cons: Can lead to higher memory allocation and potentially slower performance due to object creation.

**Library/Lib-Fu:**

None mentioned in the provided JSON. However, it's worth noting that `Array.prototype.reduce()` is a built-in method in JavaScript, which means no external library is required for this test case.

**Special JS feature/syntax:**

None explicitly mentioned in the provided JSON, but some older versions of JavaScript (e.g., ES5) did not support object destructuring or rest operator (`...`), which might be used in some modern approaches. However, since the benchmark uses the `Object.fromEntries()` method and the reduce() methods with accumulator objects, it's likely that the test is written for a more recent version of JavaScript (e.g., ES6+).

**Other alternatives:**

Some alternative approaches could include:

* Using `Array.prototype.map()` to create an array of key-value pairs and then using `Object.fromEntries()` or another method to convert it into an object.
* Using a library like Lodash, which provides utility functions for working with arrays and objects.
* Using a different approach, such as using `Map` data structure instead of objects.

However, since the test case uses built-in methods (`Array.prototype.reduce()`) and is comparing specific approaches, these alternatives might not be directly applicable or relevant to the test.

Latest run results:

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

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

Browser/OS: Chrome 100 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	7323.4 Ops/sec
Reduce (reuse object)	10282.6 Ops/sec
Reduce (creating temporary objects)	101.3 Ops/sec

Related benchmarks:

Convert Array to Object - Object.fromEntries vs reduce (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):