Benchmark: Object.fromEntries vs reduce little data

Script Preparation code:

var data = { ...Array.from(Array(10).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.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: one month ago)

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

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	384696.5 Ops/sec
Reduce (reuse object)	2284717.5 Ops/sec
Reduce (creating temporary objects)	1226408.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark provided compares different approaches to convert an object into another object using JavaScript. Specifically, it tests how efficiently various methods can create a new object with values transformed to strings. The test cases involved and their implementations are as follows:

### Test Cases Explained

1. **Object.fromEntries**:
   - **Benchmark Definition**: `Object.fromEntries(Object.entries(data).map((key, value) => [key, value]));`
   - **Description**: This method uses `Object.entries` to get an array of the object's key-value pairs and then applies a `map` function to transform these pairs before converting them back into an object with `Object.fromEntries`. However, the `map` function as given won't work correctly since it should receive an array of entries (key-value pairs), not separate arguments.
   - **Pros**: It is a concise and readable one-liner that leverages modern JavaScript features. 
   - **Cons**: The mapping function used appears to have an issue in its argument handling, potentially leading to incorrect results depending on how it's executed.

2. **Reduce (reuse object)**:
   - **Benchmark Definition**: `Object.entries(data).reduce((acc, [k, v]) => { acc[k] = v.toString(); return acc; }, {});`
   - **Description**: This approach uses `Object.entries` to get key-value pairs, and `reduce` to accumulate them into a new object `acc`. The accumulator is reused in the callback, which increases performance since no new object is created for every iteration.
   - **Pros**: Higher performance because it avoids creating intermediate objects, leading to less memory overhead.
   - **Cons**: Slightly more complex to read than the one-liner methods; familiarity with destructuring and reduce is required.

3. **Reduce (creating temporary objects)**:
   - **Benchmark Definition**: `Object.entries(data).reduce((acc, [k, v]) => ({ ...acc, [k]: v.toString() }), {});`
   - **Description**: Similar to the previous case, but this method creates a new object for every iteration using the spread operator (`...`). Each new object contains all the previous accumulated results plus the new key-value pair.
   - **Pros**: Simple syntax and clear intention to build a new object iteratively.
   - **Cons**: Performance is lower due to the constant creation of left-hand side copies, leading to higher time complexity and memory usage.

### Benchmark Results Summary

The benchmark results indicate the following performance:
- **Reduce (reuse object)**: 2,284,717.5 executions per second
- **Reduce (creating temporary objects)**: 1,226,408.0 executions per second
- **Object.fromEntries**: 384,696.5 executions per second

### Performance Considerations

From these results, we can conclude the following:
- **Efficiency**: The option that reuses the accumulator (`Reduce (reuse object)`) is significantly more efficient than the others. This indicates best practices for performance, especially when working with larger datasets where high execution frequency is necessary.
- **Memory Usage**: The `Reduce (creating temporary objects)` method utilizes more memory because it results in more intermediate objects, which could lead to garbage collection overhead.
- **Readability vs. Performance**: While the more verbose `reduce` methods may require additional cognitive load to understand and maintain, the performance benefits make them worth considering, especially in performance-critical applications.

### Alternatives to the Approaches Tested

1. **Direct Looping**: A standard `for...in` loop could be employed to iterate through the keys of the object, constructing a new object directly. This could offer a balance between performance and clarity.
2. **Libraries**: Libraries such as Lodash can provide utility functions like `_.map`, and `_.reduce`, which might introduce additional features and syntactic sugar to enhance code clarity but could also involve their own performance trade-offs.
3. **Using ES6 Features**: While ES6 features like `Object.entries`, `Object.fromEntries`, and destructuring can improve code succinctness and readability, alternatives like plain JavaScript for loops or traditional methods may perform better in older or performance-sensitive contexts.

### Final Thoughts

Ultimately, the choice of method will depend on the specific requirements of the application regarding performance, readability, and maintainability. While modern JavaScript provides powerful syntax and constructs, understanding the performance implications of each can lead to better engineering decisions.

Related benchmarks:

Object.fromEntries vs reduce little data (version: 1)

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

Created: one month 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 gpt-4o-mini, generated one month ago):