Benchmark: josh's Object.fromEntries vs reduce vs map

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() }), {});
Put it in a Map
Object.fromEntries(new Map(Object.entries(data)))

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)
Put it in a Map

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 explain what is tested, compared, and their pros and cons.

**What is being tested?**

The benchmark compares four approaches to create an object from key-value pairs:

1. `Object.fromEntries`
2. `Array.prototype.reduce` (with a custom accumulator object)
3. `Array.prototype.reduce` (without creating temporary objects)
4. Using a `Map` as the intermediate data structure

**Options compared**

Here's a brief overview of each approach:

* **`Object.fromEntries`**: This method is a modern addition to JavaScript, introduced in ECMAScript 2015. It takes an iterable of key-value pairs and creates a new object from them.
* **"Reduce (reuse object)"**: In this variant, the `reduce` method is used with a custom accumulator object that is reused throughout the iteration. The callback function updates the accumulator object directly.
* **"Reduce (creating temporary objects)"**: This variant uses the same approach as the previous one but creates new temporary objects for each key-value pair.
* **"Put it in a Map"`**: This method uses a `Map` data structure to store the key-value pairs and then converts it to an object using the spread operator (`Object.fromEntries(Map())`).

**Pros and Cons**

Here are some pros and cons of each approach:

* **`Object.fromEntries`**:
	+ Pros: Modern, efficient, and easy to read.
	+ Cons: Not supported in older browsers (pre-ECMAScript 2015).
* **"Reduce (reuse object)"**:
	+ Pros: Optimizes memory usage by reusing the same accumulator object.
	+ Cons: Might lead to performance issues if the callback function is computationally expensive.
* **"Reduce (creating temporary objects)"**:
	+ Pros: Avoids potential issues with reuse of accumulator objects.
	+ Cons: Creates more objects than necessary, leading to increased memory allocation and garbage collection overhead.
* **"Put it in a Map"`**:
	+ Pros: Can be faster due to the optimized data structure and iteration.
	+ Cons: Might not be as readable or intuitive for some developers.

**Libraries used**

None of the test cases use any external libraries.

**Special JS features or syntax**

None of the test cases utilize any special JavaScript features or syntax, such as async/await, generators, or modules.

**Alternatives**

If you're looking for alternative approaches to create an object from key-value pairs, consider the following options:

1. **`Array.prototype.reduce()`**: This method is widely supported and can be used with a custom accumulator object.
2. **`Object.create()`**: This method creates a new object with the specified prototype, which can be useful if you need to inherit properties from another object.
3. **`Array.prototype.map()`**: While not directly applicable for creating an object from key-value pairs, this method can be used in combination with `Object.assign()` or other methods to achieve similar results.

Keep in mind that the best approach depends on your specific use case and performance requirements.

Latest run results:

Run details: (Test run date: 8 months ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36

Browser/OS: Chrome 122 on Linux

View result in a separate tab

Test name	Executions per second
Object.fromEntries	61.5 Ops/sec
Reduce (reuse object)	482.2 Ops/sec
Reduce (creating temporary objects)	19.1 Ops/sec
Put it in a Map	155.2 Ops/sec

Related benchmarks:

josh's Object.fromEntries vs reduce vs map (version: 0)

Comparing performance of: Object.fromEntries vs Reduce (reuse object) vs Reduce (creating temporary objects) vs Put it in a Map

Created: 8 months ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

Put it in a Map

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