Benchmark: Object.fromEntries vs reduce vs reduce-keys

Script Preparation code:

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

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data).map((key, value) => [key, value]));
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() }), {});
Reduce (reuse object) + Object.keys()
Object.keys(data).reduce((acc, k) => { acc[k] = data[k].toString(); return acc; }, {});

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)
Reduce (reuse object) + Object.keys()

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 provided benchmark and its test cases.

**Overview**

The benchmark compares three ways to create an object from an array of key-value pairs: `Object.fromEntries`, `Reduce (reuse object)`, and `Reduce (creating temporary objects)`. The script preparation code generates a large data set with 10,000 keys using the `Array.from` method and an arrow function.

**Test Cases**

1. **`Object.fromEntries`**: This test case uses the `Object.fromEntries` method to create an object from an array of key-value pairs. The benchmark definition includes `Object.entries(data).map((key, value) => [key, value])`, which first converts the data into an array of entries using `Object.entries(data)` and then maps each entry to a new array with only the key-value pair.
2. **`Reduce (reuse object)`**: This test case uses the `Reduce` method to create an object from an array of key-value pairs. The benchmark definition includes `Object.entries(data).reduce((acc, [k, v]) => { ... acc; [k]: v.toString(); return acc; }, {})`, which iterates over the data using `Object.entries(data)` and reduces it into an accumulator object using a custom function.
3. **`Reduce (creating temporary objects)`**: This test case uses the `Reduce` method to create an object from an array of key-value pairs, similar to the previous one, but creates a new object for each iteration. The benchmark definition includes `Object.entries(data).reduce((acc, [k, v]) => ({ ...acc; [k]: v.toString() }), {})`, which uses a new object literal expression on each iteration.
4. **`Reduce (reuse object) + Object.keys()`**: This test case combines the previous two approaches by first converting the data into an array of keys using `Object.keys(data)` and then reducing it into an accumulator object using the `Reduce` method.

**Library Usage**

None of the test cases use any external libraries. The `Object.fromEntries`, `Reduce`, and `Object.keys` methods are built-in JavaScript functions.

**Special JS Features/Syntax**

The test cases do not explicitly use any special JavaScript features or syntax, such as async/await, Promises, or ES modules.

**Pros and Cons of Each Approach**

1. **`Object.fromEntries`**: Pros:
	* Concise and readable code
	* Fast execution performance (most efficient)
Cons:
	* May have performance issues for very large datasets due to the overhead of creating temporary arrays.
2. **`Reduce (reuse object)`**: Pros:
	* Efficient use of memory by reusing the accumulator object
Cons:
	* Code can be more complex and harder to read, especially for those unfamiliar with the `Reduce` method.
3. **`Reduce (creating temporary objects)`**: Pros:
	* Easier code to understand and maintain due to the absence of accumulator object reuse
Cons:
	* Less efficient memory usage compared to the previous approach

**Other Alternatives**

In addition to the three test cases, other alternatives for creating an object from an array of key-value pairs could include:

1. `Array.prototype.reduce()` with a custom function that creates and updates the accumulator object.
2. Using the `Map` data structure instead of an object, which can be more efficient for large datasets.
3. Utilizing libraries like Lodash or Ramda, which provide additional utility functions for working with arrays and objects.

Keep in mind that these alternatives may not be as straightforward to implement or optimize as the three test cases provided.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.71 Safari/537.36

Browser/OS: Chrome 94 on Windows

View result in a separate tab

Test name	Executions per second
Object.fromEntries	87.1 Ops/sec
Reduce (reuse object)	719.6 Ops/sec
Reduce (creating temporary objects)	27.5 Ops/sec
Reduce (reuse object) + Object.keys()	539.9 Ops/sec

Related benchmarks:

Object.fromEntries vs reduce vs reduce-keys (version: 0)

Comparing performance of: Object.fromEntries vs Reduce (reuse object) vs Reduce (creating temporary objects) vs Reduce (reuse object) + Object.keys()

Created: 3 years ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

Reduce (reuse object) + Object.keys()

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