Benchmark: Object.fromEntries vs reduce (clean)

Script Preparation code:

var items = [...Array(10000)]
var data = { ...items.keys() }

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data))
Reduce (reuse object)
items.reduce((acc, value) => { acc[value] = value return acc }, {})
Reduce (array to Map)
items.reduce((result, next) => result.set(next, next), new Map)
Reduce (array to Set)
items.reduce((result, next) => result.add(next), new Set)
Init (Object to Map)
new Map(Object.entries(data))
Init Set (from array using `Object.values`)
new Set(Object.entries(items))
Init Set (from array)
new Set(items)
From Object to Map to Object
Object.fromEntries(new Map(Object.entries(data)))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
Reduce (reuse object)
Reduce (array to Map)
Reduce (array to Set)
Init (Object to Map)
Init Set (from array using `Object.values`)
Init Set (from array)
From Object to Map to Object

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 dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided JSON represents a benchmark suite that compares different approaches to convert an object from entries to another data structure (Map or Set). The test cases are:

1. **Object.fromEntries**: A modern JavaScript method introduced in ECMAScript 2015, which converts an array of key-value pairs to an object.
2. **Reduce (reuse object)**: A traditional JavaScript approach using the `reduce()` method, creating a new object by iterating over the array and assigning values to it.
3. **Reduce (array to Map)**: Similar to the previous one, but instead of creating a new object, it creates a new Map.
4. **Reduce (array to Set)**: Another traditional approach using `reduce()`, this time creating a new Set.
5. **Init (Object to Map)**: Creating an empty Map and then populating it with entries from the array.
6. **Init Set (from array using `Object.values`)**: Creating an empty Set and then populating it with values from the array using `Object.values()`.
7. **Init Set (from array)**: Creating a new Set directly from the array.
8. **From Object to Map to Object**: A sequence of operations: creating a Map, converting it to entries, and finally creating an object from those entries.

Now, let's discuss the pros and cons of each approach:

* **Object.fromEntries**: This is a modern, concise, and efficient method that creates an object directly from key-value pairs. It's widely supported in recent browsers.
* **Reduce (reuse object)**: This traditional approach can be slower and more memory-intensive than `Object.fromEntries`, as it creates a new object by assigning values to it iteratively.
* **Reduce (array to Map)** and **Init Set (from array using `Object.values`)**: These approaches are similar, but the former is slightly faster due to the Map's inherent performance benefits. However, they both require more memory than creating an object directly from entries.
* **Reduce (array to Set)**: This approach is less efficient than others, as Sets have slower insertion and lookup times compared to Maps or objects.

Considerations:

* Memory usage: Creating a new object using `Object.fromEntries` might be the most memory-efficient option, especially for large datasets. In contrast, traditional approaches like `Reduce (reuse object)` can consume more memory.
* Performance: Modern browsers support `Object.fromEntries`, and it tends to perform well. However, specific use cases or environments may require alternative approaches.
* Code readability and maintainability: Some methods, like `Init Set (from array using `Object.values` )`, might be less readable than others due to the use of `Object.values()`. In contrast, `Reduce (reuse object)` can be more straightforward.

Other alternatives that are not part of this benchmark include:

* Using `Array.prototype.reduce()` with an accumulator object or Map/Set.
* Utilizing libraries like Lodash or Ramda for data transformation and manipulation.
* Leveraging browser-specific features, such as WebAssembly or experimental APIs.

Keep in mind that the best approach depends on the specific requirements of your project, including performance, memory constraints, code readability, and maintainability.

Latest run results:

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

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

Browser/OS: Chrome 124 on Windows

View result in a separate tab

Test name	Executions per second
Object.fromEntries	3602075.0 Ops/sec
Reduce (reuse object)	14358.4 Ops/sec
Reduce (array to Map)	6059.8 Ops/sec
Reduce (array to Set)	6848.5 Ops/sec
Init (Object to Map)	3416972.8 Ops/sec
Init Set (from array using `Object.values`)	1417.8 Ops/sec
Init Set (from array)	9918.0 Ops/sec
From Object to Map to Object	2130119.8 Ops/sec

Related benchmarks:

Object.fromEntries vs reduce (clean) (version: 5)

Comparing performance of: Object.fromEntries vs Reduce (reuse object) vs Reduce (array to Map) vs Reduce (array to Set) vs Init (Object to Map) vs Init Set (from array using `Object.values`) vs Init Set (from array) vs From Object to Map to Object

Created: 7 months ago by: Registered User

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (array to Map)

Reduce (array to Set)

Init (Object to Map)

Init Set (from array using `Object.values`)

Init Set (from array)

From Object to Map to Object

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