Benchmark: Object.fromEntries vs reduce (large dataset)

Script Preparation code:

var data = Array.from(Array(10000).keys());

Tests:

Object.fromEntries (with transform data)
const createObject = (value) => ({ arbitraryKey: value }); Object.fromEntries(data.map((key, value) => { const newValue = createObject(value); return [key, newValue]; }));
Reduce (reuse object)
Object.entries(data).reduce((acc, [k, v]) => { acc[k] = v.toString(); return acc; }, {});
Reduce (creating temporary objects)
Object.entries(data).reduce((acc, [k, v]) => ({ ...acc, [k]: v.toString() }), {});

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: 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)	2380.9 Ops/sec
Reduce (reuse object)	3254.3 Ops/sec
Reduce (creating temporary objects)	109.7 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript benchmark that tests the performance of two approaches to create an object from an array of key-value pairs: `Object.fromEntries` with and without transforming the data, and the `reduce` method.

**Options Compared**

Three options are compared:

1. **`Object.fromEntries`**: This method creates an object by passing an iterable (in this case, an array) as a list of key-value pairs.
2. **`Reduce` method**: This method applies a function to each element in an array and returns the accumulated value.

**Pros and Cons**

* **`Object.fromEntries`**:
	+ Pros: more concise and readable, eliminates the need for explicit loops or transformations.
	+ Cons: may be slower due to the overhead of creating an object and iterating over the array.
* **`Reduce` method with temporary objects** (`reduce (creating temporary objects)`):
	+ Pros: can be faster by avoiding the creation of a new object for each iteration.
	+ Cons: requires more explicit code, which can increase readability but also debugging complexity.

**Transforming Data**

In one of the test cases, `Object.fromEntries` is used with an additional transformation step using the `createObject` function. This adds an extra layer of complexity and potential performance overhead.

**Library Usage**

There is no library usage in this benchmark that affects the execution results.

**Special JS Features or Syntax**

None are mentioned in the provided code snippets.

**Other Considerations**

* The benchmark uses a large dataset (10,000 elements) to test performance, which may not be representative of smaller datasets.
* The `reduce` method with temporary objects approach may have better cache locality and parallelization opportunities on multi-core CPUs.
* Browser-specific optimizations or features (e.g., Chrome's JavaScript engine) can influence the results.

**Alternatives**

Other alternatives for creating an object from an array of key-value pairs could include:

1. **For...of loop**: `const obj = {}; for (const [key, value] of data) { obj[key] = createObject(value); }`
2. **Array.prototype.forEach**: `data.forEach((value) => { const newValue = createObject(value); obj[value] = newValue; });`
3. **Array.prototype.reduce() without the accumulator object**: `const result = Array.from(data).reduce((acc, value) => ({ ...acc, [value]: createObject(value) }), {});`

These alternatives may have different performance characteristics and trade-offs compared to the tested approaches.

Related benchmarks:

Object.fromEntries vs reduce (large 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 2 months ago):