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: 2 years 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

for...of

5K/s

forEach

5K/s

Reduce (reuse object)

4K/s

Map

2K/s

Object.fromEntries

304/s

View exact numbers

Test name	Executions per second
✓ for...of	4,636 Ops/sec
forEach	4,549 Ops/sec
Reduce (reuse object)	4,030 Ops/sec
Map	2,410 Ops/sec
Object.fromEntries	304 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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: 2 years ago by: Guest

Go to the latest result

Object.fromEntries

Reduce (reuse object)

for...of

Map

forEach

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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: 2 years ago by: Guest

Go to the latest result

Object.fromEntries

Reduce (reuse object)

for...of

Map

forEach

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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