Benchmark: Object.fromEntries vs reduce - no map - small array

Script Preparation code:

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

Tests:

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

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 (Windows NT 10.0; Win64; x64; rv:100.0) Gecko/20100101 Firefox/100.0

Browser/OS: Firefox 100 on Windows

View result in a separate tab

Test name	Executions per second
Object.fromEntries	250615.7 Ops/sec
Reduce (reuse object)	189982.7 Ops/sec
Reduce (creating temporary objects)	4805.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**Benchmark Definition:**
The benchmark measures the performance of two different approaches to create an object from key-value pairs:

1. `Object.fromEntries`
2. `reduce` (with two variations)
	* "Reuse object" variant
	* "Creating temporary objects" variant

The benchmark is designed for a small array with 100 elements, and it doesn't use the `Array.prototype.map()` method.

**Options compared:**

1. **Object.fromEntries**: Creates an object from key-value pairs using the `Object.fromEntries` method.
2. **Reduce (Reuse object)**: Uses the `reduce()` method to iterate over the array of key-value pairs and create an object, reusing the same accumulator object (`acc`) for each iteration.
3. **Reduce (Creating temporary objects)**: Similar to the previous variant, but creates a new temporary object on each iteration instead of reusing the same one.

**Pros and Cons:**

1. `Object.fromEntries`:
	* Pros: concise and easy to read, eliminates the need to manage an accumulator object.
	* Cons: might incur additional overhead due to method call and object creation.
2. **Reduce (Reuse object)**:
	* Pros: reuses the same accumulator object, potentially reducing memory allocation and deallocation overhead.
	* Cons: requires careful management of the accumulator object to avoid overwriting existing properties, and the code can become less readable if not done correctly.
3. **Reduce (Creating temporary objects)**:
	* Pros: creates a new temporary object on each iteration, which might be beneficial for some use cases where a fresh start is necessary.
	* Cons: introduces more memory allocation and deallocation overhead compared to reusing an accumulator object.

**Libraries and features used:**

None explicitly mentioned in the benchmark definition. However, the `Object.fromEntries()` method uses the built-in JavaScript library.

**Special JS feature or syntax:**
The benchmark uses the `reduce()` method, which is a common array iteration method in JavaScript. The use of this method allows for concise code and efficient iteration over arrays.

**Other alternatives:**

1. Using a library like Lodash or Ramda to implement the `reduce` variant could provide additional features and optimizations.
2. Implementing the `Object.fromEntries()` equivalent using a different approach, such as iterating over an array of key-value pairs using `for...of` loops or manual indexing.

In summary, the benchmark provides a simple yet effective way to compare the performance of three approaches for creating objects from arrays of key-value pairs in JavaScript. The results can help developers understand the trade-offs between these methods and choose the best approach depending on their specific use case requirements.

Related benchmarks:

Object.fromEntries vs reduce - no map - small array (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 one month ago):