Benchmark: Transform: Object.fromEntries vs reduce (small dataset)

Script Preparation code:

var ENTRIES = 10000;
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

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark definition and test cases.

**Benchmark Definition**

The website `MeasureThat.net` provides a JSON representation of a JavaScript microbenchmark. The current benchmark is:

```
{
  "Name": "Transform: Object.fromEntries vs reduce (small dataset)",
  "Description": null,
  "Script Preparation Code": "var ENTRIES = 10000;\r\nvar data = Array.from(Array(ENTRIES).keys()).map(key => ({id: key, someProp: key + 1}))\r\nvar createObject = (value) => ({ id: value.id });",
  "Html Preparation Code": null
}
```

This benchmark defines a script preparation code that creates an array of objects with `id` and `someProp` properties. The `createObject` function is used to transform the object. The benchmark also defines three test cases:

**Test Cases**

The test cases are defined in the following JSON structure:
```json
[
  {
    "Benchmark Definition": "Object.fromEntries( data.map( currentObj => {\r\n  const transformedObj = createObject( currentObj );\r\n  return [ transformedObj.id, transformedObj ];\r\n}));",
    "Test Name": "Object.fromEntries (with transform data)"
  },
  {
    "Benchmark Definition": "data.reduce( ( acc, currentObj ) => {\r\n  const transformedObj = createObject( currentObj );\r\n  acc[ transformedObj.id ] = transformedObj;\r\n  return acc;\r\n}, {});",
    "Test Name": "Reduce (reuse object)"
  },
  {
    "Benchmark Definition": "data.reduce( ( acc, currentObj ) => {\r\n  const transformedObj = createObject( currentObj );\r\n  return { ...acc, [ transformedObj.id ]: transformedObj };\r\n}, {} );",
    "Test Name": "Reduce (creating temporary objects)"
  }
]
```

These test cases compare three different approaches to transforming the data:

1. **`Object.fromEntries(data.map(...))`**: This approach uses `Object.fromEntries()` to create an object from an array of key-value pairs, where each pair is a transformed version of the original object.
2. **`data.reduce((acc, currentObj) => ...)```**: This approach uses `reduce()` to iterate over the data and accumulate transformed objects in an accumulator object.
3. **`data.reduce((acc, currentObj) => {...; return acc}`**: This approach is similar to the previous one, but it creates a new temporary object for each iteration, which may lead to performance differences.

**Library: Lodash**

The `createObject()` function used in the test cases is likely a custom implementation, but if you're using the same benchmark, it might be a part of the Lodash library. However, the specific version or implementation is not specified in this benchmark definition.

**JavaScript Features and Syntax**

This benchmark does not explicitly use any special JavaScript features or syntax beyond what's standard in modern JavaScript (ECMAScript 2020). The only notable feature is `Object.fromEntries()`, which was introduced in ECMAScript 2019.

**Pros and Cons of Different Approaches**

Here are some pros and cons of each approach:

1. **`Object.fromEntries()`**: Pros:
	* Simple and concise syntax.
	* Efficient for large datasets ( O(n) time complexity).
Cons:
	* May incur additional overhead due to the `fromEntries()` function.
2. **`reduce()`**: Pros:
	* Flexible and customizable accumulator object.
	* Can be used with various reduce functions (e.g., `Array.prototype.reduce()`, custom implementation).
Cons:
	* May lead to performance issues if unnecessary temporary objects are created.
3. **`Reduce (creating temporary objects)`**: Pros:
	* Can avoid potential memory leaks by not using `Object.fromEntries()` or other accumulators.

**Alternatives**

For this specific benchmark, the alternatives would be:

1. **Manual loop**: Implementing a manual loop to iterate over the data and accumulate transformed objects.
2. **Other reduce functions**: Using different reduce functions (e.g., `Array.prototype.reduce()`, custom implementation) that might have performance differences.

However, for microbenchmarks like this one, small variations in code syntax or library usage are often negligible, and the focus is on observing the performance differences between various approaches.

Latest run results:

Run details: (Test run date: one year 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)	1410.5 Ops/sec
Reduce (reuse object)	2563.3 Ops/sec
Reduce (creating temporary objects)	106.9 Ops/sec

Related benchmarks:

Transform: Object.fromEntries vs reduce (small dataset) (version: 0)

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

Created: one year 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>

Experimental features:

Fastest: N/A

Slowest: N/A

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