Benchmark: Map & Object.fromEntries vs reduce

Script Preparation code:

var data = Array.from(Array(10000).keys());
var f = v => v + ';';

Tests:

map & fromEntries
Object.fromEntries(data.map(x => [x, f(x)]));
reduce
data.reduce((acc, x) => ({...acc, [x]: f(x)}), {});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
map & fromEntries
reduce

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark JSON and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark is comparing two approaches:

1. Using `Object.fromEntries` with an array of key-value pairs created using `data.map()`.
2. Using `Array.prototype.reduce()` to accumulate an object with key-value pairs from the same data source.

Both approaches aim to create an object from a data set, but they have different implementation details.

**Options Compared**

The two options are:

1. **`Object.fromEntries`**: A modern JavaScript method introduced in ECMAScript 2017, which creates an object by passing an array of key-value pairs.
2. **`Array.prototype.reduce()`**: A common method for accumulating data in an array, which can be used to create an object.

**Pros and Cons**

1. **`Object.fromEntries`**:
	* Pros: Easy to read and write, concise syntax, modern JavaScript feature (ECMAScript 2017).
	* Cons: Might have performance overhead due to its inherent complexity.
2. **`Array.prototype.reduce()`**:
	* Pros: Mature, widely supported, and well-understood algorithm.
	* Cons: More verbose than `Object.fromEntries`, might lead to additional computations.

**Library/Functionality**

There is no specific library used in this benchmark. Both `Object.fromEntries` and `Array.prototype.reduce()` are built-in JavaScript functions.

**Special JS Feature/Syntax**

The benchmark uses the modern JavaScript feature `ECMAScript 2017` ( Introduced in Firefox 91), specifically `Object.fromEntries`. This feature was added to provide a concise way to create objects from arrays of key-value pairs.

**Other Alternatives**

Alternative approaches could include:

1. **Manual object creation**: Using `Array.prototype.forEach()` or `Array.prototype.forEach.call()` to iterate over the data array and create an object.
2. **Using a library function**: Depending on the specific use case, alternative libraries like Lodash might provide optimized functions for creating objects from arrays.

In conclusion, this benchmark compares two approaches to create an object from a data set: using `Object.fromEntries` with modern JavaScript feature (ECMAScript 2017) and using `Array.prototype.reduce()`. Both options have their pros and cons, and the choice ultimately depends on the specific use case, personal preference, or project requirements.

Latest run results:

Run details: (Test run date: 16 days ago)

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
map & fromEntries	1256.4 Ops/sec
reduce	156.4 Ops/sec

Related benchmarks:

Map & Object.fromEntries vs reduce (version: 0)

Comparing performance of: map & fromEntries vs reduce

Created: 3 years ago by: Guest

Jump to the latest result

map & fromEntries

reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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