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

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/123.0.0.0 Safari/537.36

Browser/OS: Chrome 123 on Windows

View result in a separate tab

Reduce (reuse object)

4K/s

forEach

3K/s

Reduce (reuse object, Object.keys)

2K/s

forEach (Object.keys)

2K/s

Map

2K/s

Object.fromEntries

2K/s

Object.assign

370/s

Reduce (creating temporary objects)

120/s

View exact numbers

Test name	Executions per second
✓ Reduce (reuse object)	3,585 Ops/sec
forEach	3,382 Ops/sec
Reduce (reuse object, Object.keys)	2,199 Ops/sec
forEach (Object.keys)	2,178 Ops/sec
Map	2,014 Ops/sec
Object.fromEntries	1,525 Ops/sec
Object.assign	370 Ops/sec
Reduce (creating temporary objects)	120 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 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.

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

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

Go 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>

Fastest: N/A

Slowest: N/A

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

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

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

Go 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>

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 Reduce (creating temporary objects) vs Map vs forEach vs Object.assign vs forEach (Object.keys) vs Reduce (reuse object, Object.keys)`