Benchmark: Object.fromEntries vs reduce vs forEach

Script Preparation code:

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

Tests:

1. Assign with forEach
let ret = {}; data.forEach(v => { ret[v] = v + 1; });
2. Object.fromEntries
Object.fromEntries(data.map((v) => [v, v + 1]));
3. reduce (reuse object)
data.reduce((acc, v) => { acc[v] = v + 1; return acc; }, {});
4. reduce (reuse object 2)
data.reduce((acc, v) => (acc[v] = v + 1, acc), {})
5. reduce (temporary object 1)
data.reduce((acc, v) => Object.assign(acc, {[v]: v + 1}), {});
6. reduce (temporary object 2)
data.reduce((acc, v) => ({...acc, [v]: v + 1}), {});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
1. Assign with forEach
2. Object.fromEntries
3. reduce (reuse object)
4. reduce (reuse object 2)
5. reduce (temporary object 1)
6. reduce (temporary object 2)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 11; HD1903) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.74 Mobile Safari/537.36

Browser/OS: Chrome Mobile 95 on Android

View result in a separate tab

Test name	Executions per second
1. Assign with forEach	624.7 Ops/sec
2. Object.fromEntries	388.5 Ops/sec
3. reduce (reuse object)	480.7 Ops/sec
4. reduce (reuse object 2)	613.4 Ops/sec
5. reduce (temporary object 1)	11.4 Ops/sec
6. reduce (temporary object 2)	24.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The provided JSON represents a benchmark test on MeasureThat.net, which compares the performance of three approaches: `Object.fromEntries`, `reduce` (with and without reusing an object), and using the `forEach` method. The test measures how fast each approach can create an object with key-value pairs from a given array.

**Options Compared**

1. **Object.fromEntries**: This method creates a new object by parsing an array of key-value pairs.
2. **reduce** (with reusing an object): This method iterates over the array and reduces it to a single object, reusing the accumulator object for each iteration.
3. **forEach**: This method iterates over the array and performs a callback function on each element.

**Pros and Cons of Each Approach**

1. **Object.fromEntries**:
	* Pros: Fast, concise, and readable syntax.
	* Cons: May create multiple objects if used with a large number of key-value pairs, as it only returns one object.
2. **reduce (with reusing an object)**:
	* Pros: Efficient use of memory, as the accumulator object is reused throughout the iteration.
	* Cons: Can be slower due to the overhead of managing the accumulator object, and may lead to unexpected behavior if not used carefully.
3. **forEach**:
	* Pros: Simple and straightforward syntax, easy to understand for beginners.
	* Cons: May be slower due to the need to create a new object on each iteration, which can lead to memory allocation overhead.

**Library:**

None explicitly mentioned in the provided JSON. However, `Array.prototype.forEach` is a standard JavaScript method that's widely used and understood.

**Special JS Feature/Syntax:**

None explicitly mentioned in the provided JSON. However, using `reduce` with reusing an object requires some knowledge of functional programming concepts, such as accumulator functions and state management.

**Other Alternatives:**

For this specific benchmark, other alternatives might include:

* Using `Array.prototype.map` to create a new array of key-value pairs, which could be compared against the three methods mentioned above.
* Implementing a custom loop using a variable to store the result object, which would require similar performance characteristics as the three tested approaches.

In conclusion, this benchmark provides a valuable comparison of three JavaScript methods for creating objects from arrays. Understanding the pros and cons of each approach can help developers choose the most efficient method for their specific use case.

Related benchmarks:

Object.fromEntries vs reduce vs forEach (version: 0)

Comparing performance of: 1. Assign with forEach vs 2. Object.fromEntries vs 3. reduce (reuse object) vs 4. reduce (reuse object 2) vs 5. reduce (temporary object 1) vs 6. reduce (temporary object 2)

Created: 3 years ago by: Registered User

Jump to the latest result

1. Assign with forEach

2. Object.fromEntries

3. reduce (reuse object)

4. reduce (reuse object 2)

5. reduce (temporary object 1)

6. reduce (temporary object 2)

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