Benchmark: Object.fromEntries vs reduce test 2

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: one year ago)

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

Browser/OS: Chrome 116 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	183.7 Ops/sec
Reduce (reuse object)	1714.3 Ops/sec
Reduce (creating temporary objects)	49.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark definition and test cases.

**What is being tested?**

The provided JSON represents a microbenchmark that compares three approaches to creating an object from an array of key-value pairs:

1. Using `Object.fromEntries()`.
2. Using the `reduce()` method with an accumulator object.
3. Using the `reduce()` method but creating temporary objects in the process.

**Options comparison**

The benchmark is comparing the performance of these three approaches on a large dataset (`data`).

**Pros and Cons of each approach:**

1. **Object.fromEntries()**:
	* Pros: Concise, efficient, and well-supported by modern browsers.
	* Cons: Not supported in older browsers (e.g., Internet Explorer), and may not be optimized for smaller datasets.
2. **Reduce (reuse object)**:
	* Pros: Efficient use of accumulator object, reducing memory allocation.
	* Cons: May have performance overhead due to repeated assignments to the accumulator.
3. **Reduce (creating temporary objects)**:
	* Pros: Similar to the previous approach but without reusing the accumulator object.
	* Cons: Creates additional temporary objects, which can increase memory allocation and garbage collection.

**Library usage**

The benchmark uses no external libraries beyond what is built into JavaScript or the browser's implementation. The `reduce()` method is a native JavaScript function.

**Special JS features/syntax**

There are no special JS features or syntax used in this benchmark. The focus is on comparing the performance of three common approaches to creating an object from an array of key-value pairs.

**Other alternatives**

If you're looking for alternative methods, consider:

1. Using `Array.prototype.reduce()` with a callback function instead of using the accumulator object.
2. Utilizing libraries like Lodash or Underscore.js for more concise and efficient data manipulation.
3. Exploring browser-specific optimizations or polyfills for older browsers that may not support `Object.fromEntries()`.

Related benchmarks:

Object.fromEntries vs reduce test 2 (version: 0)

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

Created: one year 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 one month ago):