Benchmark: Object.fromEntries vs reduce vs Map vs for of vs forEach

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.toString(); return acc; }, {});
for...of
const result = {}; for (const [key, value] of Object.entries(data)) { result[key] = value; } return result;
Map
Object.entries(data).reduce((acc, [k, v]) => { acc.set(k, v.toString()) return acc; }, new Map());
forEach
const result = {}; Object.entries(data).forEach(entry => { const [key, value] = entry; result[key] = value; }); return result;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
Reduce (reuse object)
for...of
Map
forEach

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 121 on Windows

View result in a separate tab

Test name	Executions per second
Object.fromEntries	304.2 Ops/sec
Reduce (reuse object)	4029.9 Ops/sec
for...of	4635.5 Ops/sec
Map	2409.8 Ops/sec
forEach	4548.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided JSON represents a benchmark comparison between four methods: `Object.fromEntries`, `reduce` (reusing an object), `for...of`, and `Map`. The goal is to determine which method is the most efficient in creating an object from an array of key-value pairs.

**Method Options Compared**

1. **`Object.fromEntries`**: This method creates a new object by passing an array of key-value pairs to the constructor.
2. **`reduce` (reusing an object)**: This method uses the `reduce` function to create an object by iteratively adding key-value pairs to an initial empty object.
3. **`for...of`**: This loop construct is used to iterate over the array and add key-value pairs to a new object.
4. **`Map`**: This method creates a new Map object, which is similar to an object but has additional features like set operations.

**Pros and Cons of Each Approach**

1. **`Object.fromEntries`**:
	* Pros: Simple, concise, and efficient (around 240 executions per second).
	* Cons: Not as flexible as other options, as it only works with arrays.
2. **`reduce` (reusing an object)**:
	* Pros: Flexible, can handle large datasets, and allows for reuse of the initial object.
	* Cons: Can be slower due to object reassignment (around 400 executions per second).
3. **`for...of`**:
	* Pros: Easy to read and maintain, flexible in terms of array iteration.
	* Cons: Can be slower than other options due to loop overhead (around 300 executions per second).
4. **`Map`**:
	* Pros: Fast, efficient, and flexible, with set operations like `set()` and `get()`.
	* Cons: Requires more memory and can be less intuitive for simple object creation.

**Library Usage**

The benchmark uses the built-in `Array.from()` method to create an array of key-value pairs. No external libraries are required.

**Special JS Features/Syntax**

None mentioned in the provided JSON.

**Other Alternatives**

Additional methods that could be used for creating an object from an array of key-value pairs include:

1. `Object.create()`: Creates a new object by passing an existing object as the prototype.
2. `Array.prototype.reduce.call()`: Uses the `reduce` function with an initial value to create an object.
3. Custom-built loops using `push()` or `forEach()`.

Keep in mind that these alternatives may have different performance characteristics and might not be suitable for all use cases.

**Benchmark Result Interpretation**

The provided benchmark results show the number of executions per second for each method on a desktop Chrome browser. The fastest method is `Object.fromEntries`, followed by `for...of`. While this provides insight into the relative performance of these methods, it's essential to consider other factors like code readability, maintainability, and flexibility when choosing an approach.

Related benchmarks:

Object.fromEntries vs reduce vs Map vs for of vs forEach (version: 0)

Comparing performance of: Object.fromEntries vs Reduce (reuse object) vs for...of vs Map vs forEach

Created: 10 months ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

for...of

Map

forEach

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