Benchmark: Object.fromEntries vs reduce object.assign vs for in

Script Preparation code:

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

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data).map((key, value) => [key, value]));
Reduce (object assign)
Object.entries(data).reduce((object, [key, value]) => Object.assign(object, { [key]: value }), {})
Reduce (creating temporary objects)
Object.entries(data).reduce((acc, [k, v]) => ({ ...acc, [k]: v.toString() }), {});
For in
const result = {}; for (const key in data) { result[key] = data[key] }
Object.fromEntries with Generator
Object.fromEntries([ ...(function* () { for (const key in data) { yield [key, data[key]]; } })() ]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
Reduce (object assign)
Reduce (creating temporary objects)
For in
Object.fromEntries with Generator

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's being tested.

**Benchmark Overview**

The benchmark compares four different approaches for creating an object from a collection of key-value pairs:

1. `Object.fromEntries`
2. `reduce` with `object.assign`
3. `reduce` with creating temporary objects
4. `for...in`

**Options Compared**

Each option is compared in terms of execution speed and performance.

**Pros and Cons of Each Approach:**

1. **`Object.fromEntries`**:
	* Pros: concise, efficient, and modern.
	* Cons: supported by older browsers (IE 11+), may have compatibility issues with certain libraries or frameworks.
2. **`reduce` with `object.assign`**:
	* Pros: widely supported, compatible with older browsers, and can be more readable for those familiar with the `reduce` method.
	* Cons: creates a new object on each iteration, leading to higher memory usage and slower performance for large datasets.
3. **`reduce` with creating temporary objects**:
	* Pros: similar to the previous approach but avoids creating a new object, resulting in better performance and lower memory usage.
	* Cons: requires more explicit code and may be less readable for those unfamiliar with this pattern.
4. **`for...in`**:
	* Pros: widely supported, compatible with older browsers, and can be more readable for those familiar with the `for...in` loop.
	* Cons: slower performance due to the overhead of iterating over a collection using `for...in`.

**Library Used**

In this benchmark, the `Array.from()` method is used to create an array from a range of numbers. This library is supported by modern browsers and provides a concise way to achieve a specific result.

**Special JS Feature/Syntax**

There is no special JavaScript feature or syntax being tested in this benchmark. All options are built-in methods or language constructs that are widely supported across different browsers and environments.

**Alternative Approaches**

For creating objects from collections of key-value pairs, some alternative approaches include:

* Using a library like Lodash's `_.fromPairs()` method
* Utilizing the `Object.create()` method in conjunction with `Array.from()`
* Implementing a custom solution using JavaScript's built-in methods and language constructs

Keep in mind that these alternatives may offer different trade-offs in terms of performance, memory usage, and compatibility.

Latest run results:

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

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

Browser/OS: Safari 17 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	352.3 Ops/sec
Reduce (object assign)	173.5 Ops/sec
Reduce (creating temporary objects)	0.2 Ops/sec
For in	1207.7 Ops/sec
Object.fromEntries with Generator	833.8 Ops/sec

Related benchmarks:

Object.fromEntries vs reduce object.assign vs for in (version: 0)

Comparing performance of: Object.fromEntries vs Reduce (object assign) vs Reduce (creating temporary objects) vs For in vs Object.fromEntries with Generator

Created: 11 months ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (object assign)

Reduce (creating temporary objects)

For in

Object.fromEntries with Generator

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