Benchmark: Object.fromEntries x reduce

Script Preparation code:

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

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data).map((key, value) => [key, value]));
Reduce (reuse object)
Object.entries(data).reduce((acc, [k, v]) => { acc[k] = v; return acc; }, {});
Reduce (creating temporary objects)
Object.entries(data).reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {});

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)

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_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36

Browser/OS: Chrome 104 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	279.8 Ops/sec
Reduce (reuse object)	3421.3 Ops/sec
Reduce (creating temporary objects)	104.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript code is crucial to ensure that our applications are efficient and performant.

In this case, we're benchmarking two approaches: `Object.fromEntries` and `reduce` (specifically, "reuse object" and "creating temporary objects").

**What's being tested?**

The provided JSON represents a set of benchmark tests that measure the performance of these two JavaScript functions. The tests create an object with 10,000 key-value pairs using `Array.from(Array(10000).keys())` and then apply the respective function to convert it into an object.

The test cases are:

1. `Object.fromEntries`: This function takes an array of key-value pairs as input and creates a new object from it.
2. "Reduce (reuse object)": This test uses the `reduce` method to iterate over the array of key-value pairs and create an object, but instead of creating a new object each time, it reuses the same accumulator object (`{}`) to store the result.
3. "Reduce (creating temporary objects)": This test is similar to the previous one, but creates a new temporary object (`{}`) for the accumulator on each iteration.

**Options compared:**

The three options being tested are:

1. `Object.fromEntries`: A built-in function that creates an object from an array of key-value pairs.
2. "Reduce (reuse object)": A custom implementation of `reduce` that reuses the same accumulator object.
3. "Reduce (creating temporary objects)": Another custom implementation of `reduce` that creates a new temporary object on each iteration.

**Pros and Cons:**

1. `Object.fromEntries`:
	* Pros: Simple, efficient, and widely supported.
	* Cons: May not be as fast as custom implementations for very large datasets.
2. "Reduce (reuse object)":
	* Pros: Reuses the same accumulator object, reducing memory allocation overhead.
	* Cons: May have performance issues if the accumulator object is too large or complex.
3. "Reduce (creating temporary objects)":
	* Pros: Easy to implement and understand.
	* Cons: Creates multiple temporary objects, which can lead to increased memory usage and slower performance.

**Library used:**

None are explicitly mentioned in this benchmark.

**Special JS feature/syntax:**

There are no special features or syntaxes used in this benchmark. The code only uses standard JavaScript features like `Array.from`, `Object.entries`, and the `reduce` method.

**Alternatives:**

Other alternatives for creating an object from an array of key-value pairs could be:

* Using a library like Lodash's `pickBy` function
* Implementing a custom function using template literals or string interpolation

However, it's worth noting that the built-in `Object.fromEntries` function is often the most efficient and convenient way to achieve this task.

Related benchmarks:

Object.fromEntries x reduce (version: 0)

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

Created: 2 years ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

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