Benchmark: Transform: Object.fromEntries vs reduce (100 entries)

Script Preparation code:

var ENTRIES = 100;
var data = Array.from(Array(ENTRIES).keys()).map(key => ({id: key, someProp: key + 1}))
var createObject = (value) => ({ id: value.id });

Tests:

Object.fromEntries (with transform data)
Object.fromEntries( data.map( currentObj => { const transformedObj = createObject( currentObj ); return [ transformedObj.id, transformedObj ]; }));
Reduce (reuse object)
data.reduce( ( acc, currentObj ) => { const transformedObj = createObject( currentObj ); acc[ transformedObj.id ] = transformedObj; return acc; }, {});
Reduce (creating temporary objects)
data.reduce( ( acc, currentObj ) => { const transformedObj = createObject( currentObj ); return { ...acc, [ transformedObj.id ]: transformedObj }; }, {} );

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

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/119.0.0.0 Safari/537.36

Browser/OS: Chrome 119 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries (with transform data)	147094.3 Ops/sec
Reduce (reuse object)	263755.5 Ops/sec
Reduce (creating temporary objects)	110728.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided JSON represents a JavaScript microbenchmark test case, specifically measuring the performance of two different approaches to transform and reduce an array of objects.

**Transform: Object.fromEntries vs Reduce**

Two benchmark tests are compared:

1. **Object.fromEntries (with transform data)**:
	* This approach uses `Object.fromEntries` to create an object from an array of key-value pairs, where each value is another object that has been transformed using the `createObject` function.
	* The `transformedObj` variable is created by calling `createObject` on each object in the `data` array, and then passing this transformed object as a value in the `Object.fromEntries` call.
2. **Reduce (reuse object)**:
	* This approach uses the `reduce` method to iterate over the `data` array and accumulate an object with transformed objects as values.
	* The `transformedObj` variable is created by calling `createObject` on each object in the `data` array, and then assigning this transformed object as a value in the accumulator object using the reduced key (i.e., `transformedObj.id`).
3. **Reduce (creating temporary objects)**:
	* This approach is similar to the previous one but creates an intermediate object with the transformed data before creating the final output object.

**Options Compared**

The three benchmark tests are compared in terms of their performance, specifically:

* Which approach is faster
* How does the use of `Object.fromEntries` vs `reduce` methods impact performance

**Pros and Cons**

Here's a brief overview of the pros and cons of each approach:

1. **Object.fromEntries (with transform data)**:
	* Pros: Simplifies the transformation logic, easy to read and understand
	* Cons: May incur overhead due to the creation of an intermediate object, potential performance impact if `Object.fromEntries` is slow
2. **Reduce (reuse object)**:
	* Pros: Avoids creating intermediate objects, potentially more efficient memory usage
	* Cons: Requires handling transformed data directly in the accumulator object, may be less readable for complex transformations
3. **Reduce (creating temporary objects)**:
	* Pros: Combines the benefits of both approaches, allowing for intermediate object creation while avoiding excessive memory allocation
	* Cons: May introduce additional overhead due to creating an intermediate object

**Library and Purpose**

The `Object.fromEntries` function is a modern JavaScript method that creates an object from an array of key-value pairs. It was introduced in ECMAScript 2015 (ES6) and has since become a widely used method for transforming data.

The `reduce` method, on the other hand, is a fundamental JavaScript method that allows you to iterate over an array and accumulate values into an object or array.

**Special JS Feature/Syntax**

None mentioned in this specific benchmark case.

**Other Alternatives**

If you're looking for alternative approaches, consider:

* Using `Array.prototype.reduce.call()` instead of `reduce()`, which can provide more control over the accumulator object.
* Utilizing libraries like Lodash or Ramda to simplify data transformations and operations.
* Exploring other transformation methods, such as using a loop with an index variable.

Keep in mind that these alternatives may come with additional overhead, complexity, or performance implications.

Related benchmarks:

Transform: Object.fromEntries vs reduce (100 entries) (version: 0)

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

Created: 2 years ago by: Guest

Jump to the latest result

Object.fromEntries (with transform data)

Reduce (reuse object)

Reduce (creating temporary objects)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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