Benchmark: Object.fromEntries vs reduce v21

Script Preparation code:

var data = { ...Array.from(Array(10000).keys()) };

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data).map(([key, value]) => [`a_${key}`, value]))
Reduce (reuse object)
Object.entries(data).reduce((acc, [k, v]) => { acc[`a_${k}`] = v; return acc; }, {});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
Reduce (reuse object)

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 benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The benchmark compares two approaches to create an object from key-value pairs in JavaScript:

1. `Object.fromEntries`
2. Using the `reduce` method on the `entries` method of an object

**Library Usage: None**

There is no explicit library used in this benchmark.

**Special JavaScript Features or Syntax: None**

There are no special JavaScript features or syntax used in this benchmark.

**Benchmark Test Cases**

The benchmark has two test cases:

1. **Object.fromEntries**
	* This test case creates an object from key-value pairs using the `Object.fromEntries` method.
	* The input data is generated using the `Array.from` and `Array.keys()` methods, creating an array of 10,000 objects with unique keys.
2. **Reduce (Reuse Object)**
	* This test case uses the `reduce` method to create a new object from key-value pairs on the same array of objects used in the first test case.
	* The `reduce` callback function iterates through the array and adds each key-value pair to a new object, reusing an existing object to avoid creating a new one for each iteration.

**Comparison**

The benchmark compares the performance of these two approaches:

1. **Object.fromEntries**: Creates a new object from key-value pairs using the `fromEntries` method.
2. **Reduce (Reuse Object)**: Uses the `reduce` method on the `entries` method of an object to create a new object from key-value pairs, reusing an existing object.

**Pros and Cons**

1. **Object.fromEntries**:
	* Pros:
		+ Faster and more concise way to create objects from key-value pairs.
		+ Less boilerplate code required.
	* Cons:
		+ Creates a new object each time it's used, which can be inefficient for large datasets.
2. **Reduce (Reuse Object)**:
	* Pros:
		+ Reuses an existing object, reducing memory allocation and deallocation overhead.
		+ Can be more efficient for large datasets.
	* Cons:
		+ Requires the use of the `reduce` method, which can add complexity to code.
		+ May require additional manual management of object references.

**Alternative Approaches**

Other approaches to create objects from key-value pairs in JavaScript include:

1. **Object.assign()**: Assigns properties from an array of key-value pairs to a target object.
2. **forEach()**: Iterates through an array and adds each key-value pair to a target object using the `forEach` method.

However, these approaches may not offer the same level of performance or conciseness as `Object.fromEntries` or the `reduce` method.

I hope this explanation helps!

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36

Browser/OS: Chrome 108 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	530.1 Ops/sec
Reduce (reuse object)	813.3 Ops/sec

Related benchmarks:

Object.fromEntries vs reduce v21 (version: 0)

Comparing performance of: Object.fromEntries vs Reduce (reuse object)

Created: one year ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

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