Benchmark: Object.fromEntries vs reduce vs Map vs Object.assign vs forEach (fixed2)

Script Preparation code:

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

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data).map(([key, value]) => [key, value.toString()]));
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());
forEach
const result = {}; Object.entries(data).forEach(([key, value]) => { result[key] = value.toString(); });
Object.assign
Object.assign( {}, ...Object.entries(data).map(([key, value]) => ({ [key]: value })) );
forEach (Object.keys)
const result = {}; Object.keys(data).forEach((key) => { result[key] = data[key].toString(); });
Reduce (reuse object, Object.keys)
Object.keys(data).reduce((acc, k) => { acc[k] = data[k].toString(); return acc; }, {});

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
forEach
Object.assign
forEach (Object.keys)
Reduce (reuse object, Object.keys)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark and explain what is being tested.

**Benchmark Overview**

The benchmark compares six different methods to create an object from a collection of key-value pairs:

1. `Object.fromEntries`
2. `Reduce` (with various approaches)
3. `Map`
4. `forEach`
5. `Object.assign`
6. `Reduce` (creating temporary objects)

**Methods Comparison**

Here's a brief overview of each method and their pros/cons:

1. **Object.fromEntries**: This method is introduced in ECMAScript 2018 and allows creating an object from an iterable (e.g., an array or a map). It's a concise way to create an object, but its performance can vary depending on the browser implementation.
	* Pros: Concise, easy to read.
	* Cons: Performance may be lower due to overhead of `Object.fromEntries`.
2. **Reduce**: This method applies a callback function to each element in an array and reduces it to a single output value. It's commonly used with objects, but can also be used with other iterables.
	* Pros: Flexible, can create objects from various iterables.
	* Cons: Can lead to performance issues if the accumulator is not properly managed.
3. **Map**: Similar to `Reduce`, `Map` applies a callback function to each element in an iterable and returns a map (object) with the results.
	* Pros: Efficient for creating maps, but less common for objects.
	* Cons: Less familiar than `Reduce`.
4. **forEach**: This method iterates over an array or iterable using a callback function.
	* Pros: Simple, easy to understand.
	* Cons: Not designed for creating objects; may lead to slower performance compared to other methods.
5. **Object.assign**: This method merges multiple sources into a single object. While not directly comparable to the others, it can be used as a workaround for creating an object from a collection of key-value pairs.
	* Pros: Simple, widely supported.
	* Cons: Not optimized for performance when creating objects; may lead to slower execution times.

**Other Considerations**

When choosing between these methods, consider the following factors:

* Performance: `Object.fromEntries` and `Map` are likely to be faster than other methods due to their implementation efficiency. However, this can vary depending on browser support.
* Code readability: `Object.fromEntries` is a concise way to create an object, making it easier to read. `Reduce` and `forEach` require more boilerplate code to achieve the same result.

**Benchmark Results**

The provided benchmark results show that:

* `Object.fromEntries` has relatively high execution times compared to other methods.
* `Map` and `Reduce` (with proper accumulator management) have better performance than others, but still lag behind `Object.fromEntries`.
* `forEach`, while simple, leads to slower performance due to its nature of iterating over an array or iterable.

Overall, the benchmark highlights the importance of choosing the right method for your specific use case, considering factors such as performance, code readability, and browser support.

Latest run results:

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

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

Browser/OS: Chrome 123 on Windows

View result in a separate tab

Test name	Executions per second
Object.fromEntries	1524.8 Ops/sec
Reduce (reuse object)	3585.4 Ops/sec
Reduce (creating temporary objects)	120.1 Ops/sec
Map	2013.8 Ops/sec
forEach	3382.2 Ops/sec
Object.assign	369.8 Ops/sec
forEach (Object.keys)	2178.2 Ops/sec
Reduce (reuse object, Object.keys)	2199.3 Ops/sec

Related benchmarks:

Object.fromEntries vs reduce vs Map vs Object.assign vs forEach (fixed2) (version: 0)

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

Created: 8 months ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

Map

forEach

Object.assign

forEach (Object.keys)

Reduce (reuse object, Object.keys)

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