Benchmark: Object.fromEntries vs reduce vs for loop

Script Preparation code:

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

Tests:

Object.fromEntries
Object.fromEntries(data.map((key) => [key, 'x']));
Reduce (creating temporary objects)
data.reduce((acc, k) => ({ ...acc, [k]: 'x' }), {});
For loop
const obj = {}; for (const d of data) { obj[d] = 'x'; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
Reduce (creating temporary objects)
For loop

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36

Browser/OS: Chrome 117 on Windows

View result in a separate tab

Test name	Executions per second
Object.fromEntries	766.8 Ops/sec
Reduce (creating temporary objects)	30.9 Ops/sec
For loop	5825.8 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 provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark is comparing three approaches to create an object with key-value pairs: `Object.fromEntries`, `reduce` (creating temporary objects), and a traditional `for` loop.

**Options Compared**

1. **`Object.fromEntries`**: This method creates an object from an array of key-value pairs.
2. **`Reduce` (creating temporary objects)**: This method uses the reduce function to create an object by iteratively adding key-value pairs.
3. **Traditional `for` loop**: This approach uses a traditional loop to iterate over the data and add key-value pairs to an object.

**Pros and Cons of Each Approach**

1. **`Object.fromEntries`**:
	* Pros: Concise, efficient, and readable code.
	* Cons: Requires modern JavaScript versions (ECMAScript 2017+).
2. **`Reduce` (creating temporary objects)**:
	* Pros: Can be more memory-efficient than `Object.fromEntries` by reusing the accumulator object.
	* Cons: May have performance implications due to object creation and mutation.
3. **Traditional `for` loop**:
	* Pros: Widely supported, no dependencies on modern JavaScript versions or libraries.
	* Cons: More verbose and potentially less efficient than other approaches.

**Library Used**

None explicitly mentioned in the benchmark definition, but it's likely that the `Array.from()` method is used, which is a built-in JavaScript method.

**Special JS Feature/Syntax**

There is no special feature or syntax being tested here; all approaches use standard JavaScript constructs. However, if we consider the usage of `Object.fromEntries`, it does demonstrate a modern JavaScript feature (ECMAScript 2017+) that might be interesting to some readers.

**Alternative Approaches**

Other alternatives for creating an object with key-value pairs could include:

* Using the spread operator (`{ ... }` or `Object.assign()`)
* Utilizing libraries like Lodash's `mapObject()` function
* Implementing a custom solution using JavaScript iterables and objects

Keep in mind that these alternative approaches may have their own pros and cons, depending on the specific use case and performance requirements.

Related benchmarks:

Object.fromEntries vs reduce vs for loop (version: 0)

Comparing performance of: Object.fromEntries vs Reduce (creating temporary objects) vs For loop

Created: one year ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (creating temporary objects)

For loop

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