Benchmark: Convert Array to Object 2 - Object.fromEntries vs reduce

Script Preparation code:

var data = Array.from(Array(10000).keys()).map(i => ({id: i, value: `val_${i}`}));

Tests:

Object.fromEntries
Object.fromEntries(data.map(obj => [obj.id, obj]));
Reduce (reuse object)
data.reduce((acc, obj) => { acc[obj.id] = obj; return acc; }, {});
Reduce (creating temporary objects)
data.reduce((acc, obj) => ({ ...acc, [obj.id]: obj }), {});

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 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.84 Safari/537.36

Browser/OS: Chrome 99 on Windows

View result in a separate tab

Test name	Executions per second
Object.fromEntries	2946.0 Ops/sec
Reduce (reuse object)	4878.4 Ops/sec
Reduce (creating temporary objects)	36.9 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript benchmark test case for the "Convert Array to Object" microbenchmark. The benchmark aims to measure the performance of two approaches:

1. **Object.fromEntries**: This method creates a new object from an array of key-value pairs. It's a relatively modern method introduced in ECMAScript 2015 (ES6).

2. **Reduce**:
   - **Reuse Object**: This approach uses the `reduce` method to create a new object, and for each iteration, it checks if the property already exists in the accumulator (`acc`). If it does, it overwrites the existing value. Then, it adds the new key-value pair to the object.
   - **Creating Temporary Objects**: This approach also uses the `reduce` method but creates temporary objects instead of reusing an existing one.

**Options Compared:**

- Object.fromEntries vs Reuse Object
- Object.fromEntries vs Creating Temporary Objects

**Pros and Cons:**

1.  **Object.fromEntries**:

*   Pros:
        *   Modern and concise syntax.
        *   Creates a new object without modifying any existing properties.
    *   Cons:
        *   May incur additional overhead due to the creation of an intermediate array.

2.  **Reuse Object (Reduce)**:

*   Pros:
        *   Can be more efficient if there are many duplicate keys because it only needs to create one temporary object.
        *   Can take advantage of existing object properties, reducing memory allocation and copy operations.
    *   Cons:
        *   More verbose syntax due to the use of callback functions.

3.  **Creating Temporary Objects (Reduce)**:

*   Pros:
        *   Provides more control over the creation process by allowing for mutable objects as accumulators.
    *   Cons:
        *   May incur additional overhead due to the repeated creation and assignment of temporary objects.

**Library:**

- None specified in this benchmark definition. However, the `Array.from()` method is used which comes from the built-in JavaScript array methods.

**Special JS Feature or Syntax:**

- None mentioned in this explanation.

To better understand these alternatives, consider the following scenarios:

*   If you're dealing with an array of objects where each object has unique properties (i.e., no duplicates), Object.fromEntries is likely a good choice due to its concise syntax.
*   In cases where there are duplicate keys or performance-critical code paths, Reuse Object might provide better efficiency by minimizing temporary object creation.

Ultimately, the best approach depends on your specific use case and requirements. The performance differences between these methods may be small for small arrays but become more pronounced with larger datasets.

**Other Alternatives:**

1.  **Lodash's `fromPairs` method**: This is another popular method used to convert an array of key-value pairs into a new object. It shares similarities with Object.fromEntries and can be useful if you prefer a specific syntax or behavior.
2.  **Using the spread operator (`...object`)**: For simple cases, this approach can be as efficient as Object.fromEntries but might not work as well for more complex scenarios where properties need to be overwritten.

Before deciding on any method, consider factors like performance, readability, and maintainability based on your specific requirements.

Related benchmarks:

Convert Array to Object 2 - Object.fromEntries vs reduce (version: 0)

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

Created: 4 years ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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