Benchmark: Object.fromEntries vs reduce without tostring function

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; return acc; }, {});
Reduce (creating temporary objects)
Object.entries(data).reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {});

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)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36

Browser/OS: Chrome 99 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	281.1 Ops/sec
Reduce (reuse object)	3337.6 Ops/sec
Reduce (creating temporary objects)	103.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark JSON and explain what is tested, compared, and considered in this JavaScript microbenchmark.

**Benchmark Overview**

The benchmark compares three approaches to create an object from an array of key-value pairs:

1. `Object.fromEntries`
2. `Object.entries.reduce` (with a reusable object as the accumulator)
3. `Object.entries.reduce` (creating temporary objects for each iteration)

**Options Compared**

* `Object.fromEntries`: A modern JavaScript method introduced in ECMAScript 2015, which creates an object from an array of key-value pairs.
* `Object.entries.reduce` with a reusable object: This approach uses the `reduce()` method to accumulate values into an object, reusing the existing object as the accumulator.
* `Object.entries.reduce` creating temporary objects: In this version, a new object is created for each iteration, accumulating values.

**Pros and Cons**

* **Object.fromEntries**: Fast, modern, and concise. It's likely to be implemented in native code by most browsers.
* **Object.entries.reduce (reuse object)**:
	+ Pros: Can reuse the existing object as the accumulator, potentially reducing memory allocation and garbage collection overhead.
	+ Cons: May incur additional overhead due to the `reduce()` method and potential object cloning.
* **Object.entries.reduce (creating temporary objects)**:
	+ Pros: Simple and easy to understand. No special library or implementation required.
	+ Cons: Potentially slower than other approaches, especially for large arrays, due to the repeated creation of new objects.

**Library/Utility Used**

None are explicitly mentioned in the benchmark code, but `Array.from()` is used to create an array from a specified number of keys. This method is a built-in utility function in JavaScript.

**Special JS Feature/Syntax**

None are explicitly mentioned or used in this benchmark.

**Other Alternatives**

Additional approaches to create an object from an array of key-value pairs might include:

* `Array.prototype.reduce()`: Similar to the second approach, but uses `reduce()` on the `Array` prototype instead.
* Manual iteration and object construction using a `for...of` loop and `Object.defineProperty()` or similar methods.
* Using libraries like Lodash or Ramda, which provide utility functions for creating objects from arrays.

It's worth noting that the choice of approach often depends on the specific use case, performance requirements, and personal preference.

Related benchmarks:

Object.fromEntries vs reduce without tostring function (version: 0)

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

Created: 2 years ago by: Guest

Jump to the latest result

Object.fromEntries

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