Benchmark: Object.fromEntries vs reduce vs Map vs foreach

Script Preparation code:

var data = { ...Array.from(Array(100).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() }), {});
Map
Object.entries(data).reduce((acc, [k, v]) => { acc.set(k, v.toString()) return acc; }, new Map());
Foreach
var acc = {}; Object.entries(data).forEach(([k, v]) => { acc[k] = v.toString(); });

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)
Map
Foreach

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript microbenchmark test case on the MeasureThat.net website. The benchmark compares four different methods for creating an object from an array of key-value pairs:

1. `Object.fromEntries()`
2. `Array.prototype.reduce()` with reuse of the accumulator object
3. `Array.prototype.reduce()` with creation of temporary objects
4. `Map` object

Let's break down each method and their pros and cons:

**1. Object.fromEntries()**

* Description: This method creates an object from an array of key-value pairs using the spread operator.
* Pros:
	+ Efficient, as it uses a single pass over the data.
	+ Simplifies code compared to other methods.
* Cons:
	+ May have performance issues if the input array is very large, due to string concatenation.
	+ Not supported in older browsers.

**2. Reduce (reuse of accumulator object)**

* Description: This method uses `reduce()` with an initial value of `{}` and reuses this accumulator object throughout the iteration. In each step, a new property is added to the accumulator using the spread operator (`...acc`).
* Pros:
	+ Efficient, as it avoids creating temporary objects.
	+ Allows for reuse of the accumulator object, reducing memory allocation.
* Cons:
	+ Can be slower due to string concatenation in modern browsers.

**3. Reduce (creation of temporary objects)**

* Description: This method uses `reduce()` with an initial value of `{}` and creates a new object (`{ ...acc }`) on each iteration, adding the new property using the spread operator (`[k]: v.toString()`).
* Pros:
	+ Easy to understand and implement.
	+ Works well in older browsers without support for `Object.fromEntries()`.
* Cons:
	+ Creates temporary objects, which can be slower.

**4. Map**

* Description: This method uses a `Map` object to create an object from an array of key-value pairs. Each iteration adds a new property to the map using `acc.set(key, value)`.
* Pros:
	+ Efficient, as it avoids creating temporary objects.
	+ Suitable for large datasets.
* Cons:
	+ May have performance issues if the input array is very large, due to map resizing.

Now, let's consider other alternatives:

* **Array.prototype.forEach()**: This method uses `forEach()` with a callback function to iterate over the array. It can be slower compared to the other methods, as it may involve additional overhead for callbacks.
* **Object.assign()**: This method uses `Object.assign()` to create an object from an array of key-value pairs. It can be slower due to string concatenation and is generally less efficient than modern methods.

In conclusion, the choice of method depends on the specific requirements of your use case:

* For most scenarios, `Object.fromEntries()` or `Reduce` (reuse of accumulator object) are suitable options, as they provide a good balance between performance and simplicity.
* If you need to work with very large datasets or require the support for older browsers without `Object.fromEntries()`, using a `Map` or `Reduce` (creation of temporary objects) might be more suitable.

Keep in mind that the specific results may vary depending on your environment, browser version, and other factors.

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/110.0.0.0 Safari/537.36

Browser/OS: Chrome 110 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	26614.4 Ops/sec
Reduce (reuse object)	271269.1 Ops/sec
Reduce (creating temporary objects)	95313.3 Ops/sec
Map	175841.9 Ops/sec
Foreach	262046.5 Ops/sec

Related benchmarks:

Object.fromEntries vs reduce vs Map vs foreach (version: 0)

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

Created: one year ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

Map

Foreach

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