Benchmark: Object.fromEntries vs reduce vs Map - Corrected fromEntries

Script Preparation code:

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

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data));
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());

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

Fastest: N/A

Slowest: N/A

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/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36

Browser/OS: Chrome 141 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	1860.3 Ops/sec
Reduce (reuse object)	2504.8 Ops/sec
Reduce (creating temporary objects)	108.7 Ops/sec
Map	1963.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared, and some considerations.

**Benchmark Definition**

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

1. `Object.fromEntries()`
2. Reducing an empty object with `Array.entries()` and a callback function
3. Creating a new object with `Object.assign()` or the spread operator (`...`)

**Script Preparation Code**

The script prepares an array of 10,000 numbers using `Array.from(Array(10000).keys())`, which generates an array of consecutive integers from 0 to 9,999.

**Individual Test Cases**

There are four test cases:

1. **Object.fromEntries()**
	* The benchmark definition creates a new object using `Object.fromEntries()` with the prepared data.
	* This approach uses a built-in method in JavaScript, which is optimized for performance and is likely to be the fastest way to create an object from an array of key-value pairs.
2. **Reduce (reuse object)**
	* The benchmark definition creates a new empty object using `{}` and then reduces it with `Array.entries()` and a callback function.
	* This approach reuses the same object for each iteration, which can lead to performance issues if the object is modified frequently.
3. **Reduce (creating temporary objects)**
	* Similar to the previous test case, but instead of reusing an object, a new empty object is created on each iteration using `{}` and then spread into with `...`.
	* This approach creates a new temporary object on each iteration, which can lead to performance issues due to object creation overhead.
4. **Map**
	* The benchmark definition creates a new Map object and reduces it with `Array.entries()` and a callback function that sets the value of the map using `set()`.
	* This approach uses a Map data structure, which is optimized for lookups and insertions. However, in this case, it's used to create an object from an array of key-value pairs.

**Pros and Cons**

1. **Object.fromEntries()**: Pros: fast, built-in method; Cons: depends on JavaScript engine implementation.
2. **Reduce (reuse object)**: Pros: potentially faster due to reusing the same object; Cons: may lead to performance issues if the object is modified frequently.
3. **Reduce (creating temporary objects)**: Pros: potentially more predictable performance; Cons: creates a new temporary object on each iteration, leading to overhead.
4. **Map**: Pros: optimized for lookups and insertions; Cons: not suitable for creating an object from an array of key-value pairs.

**Library/Functionality**

* `Object.fromEntries()`: a built-in JavaScript method that creates an object from an array of key-value pairs.
* `Array.entries()` and `Map.set()`: standard JavaScript methods used in the Reduce test cases.
* `Object.assign()` or spread operator (`...`): used in the Reduce (creating temporary objects) test case to create a new object.

**Special JS Feature/Syntax**

The benchmark uses standard JavaScript features and syntax. No special features or syntax are mentioned in the provided code snippet.

**Alternatives**

Other alternatives for creating an object from an array of key-value pairs include:

* Using `Array.reduce()` with an initial value, like this: `Object.fromEntries(Array(10000).keys().reduce((acc, k) => ({ ...acc, [k]: 0 }), {}))`
* Using a library like Lodash or Ramda, which provide utility functions for working with arrays and objects.
* Using a different data structure, such as an array of key-value pairs, rather than an object.

Related benchmarks:

Object.fromEntries vs reduce vs Map - Corrected fromEntries (version: 0)

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

Created: 3 years ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

Map

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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