Benchmark: Object.fromEntries vs reduce 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; }, {});
Reduce (creating temporary objects)
Object.entries(data).reduce((acc, [k, v]) => ({ ...acc, [k]: v.toString() }), {});
Foreach case
var initial = {}; Object.entries(data).forEach(([k, v]) => { initial[k] = v.toString(); });

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)
Foreach case

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

**What is being tested?**

MeasureThat.net is testing the performance of three different approaches to creating an object from key-value pairs: `Object.fromEntries`, `reduce` with reuse of the accumulator object, and `forEach`. The test cases compare these three methods in terms of execution speed.

**Options compared**

The options being compared are:

1. **`Object.fromEntries`**: A modern JavaScript method that creates an object from a list of key-value pairs.
2. **Reduce (reuse object)**: Using the `reduce` method with an accumulator object that is reused across iterations.
3. **Foreach case**: Using the `forEach` method to iterate over the key-value pairs and create a new object.

**Pros and Cons**

1. **`Object.fromEntries`**:
	* Pros: Simple, efficient, and modern JavaScript method.
	* Cons: May not be supported in older browsers or Node.js versions.
2. **Reduce (reuse object)**:
	* Pros: Can be more memory-efficient than creating a new object on each iteration.
	* Cons: Requires careful implementation to ensure proper reuse of the accumulator object across iterations.
3. **Foreach case**:
	* Pros: Simple and easy to implement, but may be slower due to the overhead of function calls.
	* Cons: Can lead to memory issues if not implemented carefully.

**Library and its purpose**

In this benchmark, `Object.entries` is used as a utility function to extract key-value pairs from an object. It returns an array of arrays, where each inner array contains a key-value pair.

**Special JavaScript features or syntax**

None mentioned in the provided code snippets. However, it's worth noting that `Object.fromEntries` was introduced in ECMAScript 2015 (ES6) and is supported in modern browsers and Node.js versions.

**Other alternatives**

If you need to create an object from key-value pairs without using these three methods, some alternative approaches include:

1. Using the spread operator (`...`) to spread the key-value pairs into a new object.
2. Using the `Object.assign` method or a library like Lodash's `pickBy` function.
3. Writing a custom loop to iterate over the key-value pairs and create a new object.

In general, the choice of method depends on the specific use case, performance requirements, and compatibility considerations.

Related benchmarks:

Object.fromEntries vs reduce vs forEach (version: 0)

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

Created: 4 years ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

Foreach case

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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