Benchmark: Object.fromEntries vs reduce (real object)

Script Preparation code:

var data = Object.fromEntries([...Array(10)].map((v, i) => [`field${i}`, `value${i}`]));

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() }), {});

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: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15

Browser/OS: Safari 16 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	541779.4 Ops/sec
Reduce (reuse object)	1159432.4 Ops/sec
Reduce (creating temporary objects)	587967.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark test case provided by MeasureThat.net.

**Benchmark Test Case**

The benchmark test case is designed to compare the performance of two approaches:

1. `Object.fromEntries`
2. Reducing an array of key-value pairs using the `reduce()` method

The test case uses a sample dataset with 10 fields and their corresponding values, which is created using `Object.fromEntries()`. The resulting object is then used as input for the two performance comparison methods.

**Options Compared**

The two options compared are:

1. **`Object.fromEntries`**: This method creates an object from an array of key-value pairs.
2. **Reducing an array of key-value pairs using `reduce()`**:
	* **Creating temporary objects**: The `reduce()` method is used to create a new object by iteratively combining the initial value (an empty object `{}`) with each iteration's result.
	* **Reusing existing objects**: The `reduce()` method is used to modify the initial value (the original object created using `Object.fromEntries()`) and return the resulting object.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **`Object.fromEntries`**:
	* Pros: Creates an object in a single step, which can be more efficient than repeated assignments.
	* Cons: May require additional memory allocation for the created object.
2. Creating temporary objects using `reduce()`:
	* Pros: Can be more cache-friendly since the initial value is reused and modified.
	* Cons: Requires multiple assignments to create the final object, which can lead to slower performance due to repeated memory allocations.
3. Reusing existing objects using `reduce()`:
	* Pros: Can take advantage of caching mechanisms, as the same object is reused across iterations.
	* Cons: May require more complex logic for creating and modifying the object.

**Library and Special JS Feature**

There are no libraries explicitly mentioned in this benchmark test case. However, it's worth noting that `Object.fromEntries()` is a modern JavaScript feature introduced in ECMAScript 2015 (ES6).

No special JS features or syntax are used in this benchmark test case.

**Other Alternatives**

Here are some alternative approaches that could be used for similar benchmarks:

* Using the `Array.prototype.reduce()` method with an accumulator object.
* Creating an object using a loop and assigning properties to it manually.
* Using a library like Lodash's `fromPairs()` function or a custom implementation of an object creator.

Keep in mind that the choice of approach depends on the specific requirements and constraints of the project, such as performance, memory usage, or readability.

Related benchmarks:

Object.fromEntries vs reduce (real object) (version: 1)

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

Created: one year ago by: Registered User

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 one month ago):