Benchmark: Object.fromEntries vs reduce vs. for-of

Script Preparation code:

function rand() {
  return Math.floor(Math.random() * 10000)
}
var data = Array(1000).fill(0).map((_, i) => ({ i, a: rand(), b: rand() }))

Tests:

Object.fromEntries
Object.fromEntries(data.map(({i, ...rest}) => [i, rest]));
Reduce (reuse object)
data.reduce((acc, {i, ...rest}) => { acc[i] = rest; return acc; }, {});
Reduce (creating temporary objects)
Object.entries(data).reduce((acc, {i, ...rest}) => ({ ...acc, [i]: rest }), {});
For-of
const result = {} for (const {i, ...rest} of data) { result[i] = rest; }

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)
For-of

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36

Browser/OS: Chrome 122 on Linux

View result in a separate tab

Test name	Executions per second
Object.fromEntries	14913.4 Ops/sec
Reduce (reuse object)	29408.5 Ops/sec
Reduce (creating temporary objects)	1982.1 Ops/sec
For-of	27737.5 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is tested:**

The provided JSON represents a JavaScript microbenchmark test case for the task of turning an array into an object using three different methods:

1. `Object.fromEntries()`
2. `Array.prototype.reduce()` with a reusable accumulator object
3. A simple `for...of` loop

Each test case measures the execution time of each method on a large dataset of 1000 objects.

**Comparison of options:**

The three methods have different approaches to achieving the goal:

1. **`Object.fromEntries()`**: This method creates a new object by passing an array of key-value pairs to the `fromEntries()` constructor. The resulting object is created in a single step.
2. **`Array.prototype.reduce()` with reusable accumulator**: This method uses the `reduce()` method to iterate over the array, accumulating values into a temporary object. The accumulator object is reused and returned as the result.
3. **`for...of` loop**: This method uses a traditional `for...of` loop to iterate over the array, assigning each value to a variable (`result`) that is used to construct the final object.

**Pros and cons:**

1. **`Object.fromEntries()`**:
	* Pros: Simple, concise, and efficient.
	* Cons: Can be slower for very large datasets due to the overhead of creating a new object.
2. **`Array.prototype.reduce()` with reusable accumulator**:
	* Pros: Can be faster for very large datasets since it avoids creating multiple temporary objects.
	* Cons: Requires more memory to store the temporary accumulator object and can be slower for smaller datasets due to the overhead of `reduce()`.
3. **`for...of` loop**:
	* Pros: Simple, easy to understand, and fast.
	* Cons: Can be slower than the other two methods for large datasets since it involves multiple assignments.

**Library usage:**

None of the test cases use any external libraries.

**Special JavaScript features or syntax:**

None of the test cases rely on special JavaScript features or syntax beyond standard ECMAScript syntax.

**Other alternatives:**

Some alternative approaches to turning an array into an object include:

1. Using `Array.prototype.map()` and `Object.fromEntries()`: This method can be faster than the other two methods since it avoids creating multiple temporary objects.
2. Using a library like Lodash's `mapKeys()` function: This method can provide more flexibility and convenience, but also introduces additional dependencies.

However, the test case provided focuses on comparing the performance of three basic methods (`Object.fromEntries()`, `Array.prototype.reduce()`, and a simple `for...of` loop`) rather than exploring alternative approaches.

Related benchmarks:

Object.fromEntries vs reduce vs. for-of (version: 0)

Turning an array into an object

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

Created: 4 years ago by: Registered User

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

For-of

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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