Benchmark: Object.fromEntries vs reduce less strawman

Script Preparation code:

var data = [...Array(10000)].map((_, i) => i);

Tests:

Object.fromEntries
Object.fromEntries(data.map((i) => [i, i]));
Reduce (mutate)
data.reduce((acc, i) => { acc[i] = i; return acc; }, {});
Reduce (spread)
data.reduce((acc, i) => ({ ...acc, [i]: i }), {});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
Reduce (mutate)
Reduce (spread)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:106.0) Gecko/20100101 Firefox/106.0

Browser/OS: Firefox 106 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Object.fromEntries	3220.1 Ops/sec
Reduce (mutate)	9210.9 Ops/sec
Reduce (spread)	0.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The benchmark in question compares three approaches to create an object from an array: `Object.fromEntries`, `reduce (mutate)`, and `reduce (spread)`. The test case generates an array of 10,000 integers and uses each approach to populate the object with key-value pairs, where the key is the integer value and the value is also the integer value.

**Approaches Compared**

1. **`Object.fromEntries`**: This method takes an iterable of key-value pairs and creates a new object from it.
2. **`reduce (mutate)`**: This method iterates over the array, accumulating values in the accumulator object and modifying it directly.
3. **`reduce (spread)`**: This method is similar to `reduce (mutate)`, but uses the spread operator (`...`) to create a new object.

**Pros and Cons**

1. **`Object.fromEntries`**:
	* Pros: Concise, efficient, and expressive.
	* Cons: May incur overhead due to JavaScript's built-in object creation.
2. **`reduce (mutate)`**:
	* Pros: Lightweight, flexible, and can be optimized for performance.
	* Cons: Can lead to unexpected side effects if not used carefully, as the original array is modified in place.
3. **`reduce (spread)`**:
	* Pros: Similar to `Object.fromEntries`, but with a more explicit spread operation.
	* Cons: May incur additional overhead due to the spread operator.

**Library Usage**

The benchmark uses JavaScript's built-in functions and objects, without any external libraries.

**Special JS Features or Syntax**

None mentioned in this specific benchmark, as all approaches use standard JavaScript syntax.

**Other Considerations**

When choosing an approach, consider the following:

* Performance: If speed is crucial, `reduce (mutate)` might be a better choice due to its lightweight nature.
* Readability and maintainability: `Object.fromEntries` might be more readable and easier to understand for developers familiar with this method.
* Error handling and safety: Be cautious when using `reduce (mutate)`, as it can lead to unintended side effects if not used carefully.

**Alternative Approaches**

Other approaches to create an object from an array include:

* Using the `Array.prototype.reduce()` method without modifying the original array.
* Creating a new object with the `Object.assign()` method or the spread operator (`...`).
* Using a library like Lodash, which provides the `fromPairs()` function for creating objects from key-value pairs.

Keep in mind that the choice of approach depends on your specific use case and requirements.

Related benchmarks:

Object.fromEntries vs reduce less strawman (version: 0)

Comparing performance of: Object.fromEntries vs Reduce (mutate) vs Reduce (spread)

Created: 2 years ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (mutate)

Reduce (spread)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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