Benchmark: Object.fromEntries vs lodash fromPairs vs Object.assign vs Object spread

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Tests:

Object.fromEntries
var a = [['a', 1], ['b', 2], ['c', 3]]; var b = Object.fromEntries(a);
_.fromPairs
var a = [['a', 1], ['b', 2], ['c', 3]]; var b = _.fromPairs(a);
Object.assign
var obj = {}; Object.assign(obj, { a: 1 }); Object.assign(obj, { b: 2 }); Object.assign(obj, { c: 3 });
Object spread
let obj = {}; obj = { ...obj, ...{ a: 1 }}; obj = { ...obj, ...{ b: 2 }}; obj = { ...obj, ...{ c: 3 }};

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
_.fromPairs
Object.assign
Object spread

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 8 days ago)

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries	11046887.0 Ops/sec
_.fromPairs	33016350.0 Ops/sec
Object.assign	24553392.0 Ops/sec
Object spread	15465021.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 8 days ago):

LLMs can make mistakes. Check important info.

The benchmark compares four different approaches for transforming an array of key-value pairs into an object in JavaScript. The test focuses on the performance characteristics of these methods:

1. **Object.fromEntries**: 
   - **Test Case**: `var a = [['a', 1], ['b', 2], ['c', 3]]; var b = Object.fromEntries(a);`
   - **Description**: This method was introduced in ES2019 and takes an iterable of key-value pairs (like an array of arrays) and converts it into an object. It is clean, concise, and purpose-built for this specific use-case.
   - **Pros**: Simple and expressive syntax; directly tailored for creating objects from entries.
   - **Cons**: Must be supported by the target environment (modern browsers and Node.js), which may restrict usage in older JavaScript environments.

2. **Lodash fromPairs**:
   - **Test Case**: `var a = [['a', 1], ['b', 2], ['c', 3]]; var b = _.fromPairs(a);`
   - **Description**: This method comes from the Lodash library, a popular utility library that provides helpful functions for working with arrays, objects, and more. The `_.fromPairs` method does essentially the same thing as `Object.fromEntries`.
   - **Pros**: If a project already uses Lodash, this method can be beneficial for consistency and may offer additional functions in conjunction with fromPairs.
   - **Cons**: Adds a dependency on the Lodash library, which may increase the bundle size if it’s the sole function being used. Potential performance overhead by using an external library.

3. **Object.assign**:
   - **Test Case**: `var obj = {}; Object.assign(obj, { a: 1 }); Object.assign(obj, { b: 2 }); Object.assign(obj, { c: 3 });`
   - **Description**: This method is part of the ES6 specification and is used to copy values from one or more source objects to a target object.
   - **Pros**: Supports merging properties and can consolidate properties from multiple sources. It’s also broadly supported in multiple environments.
   - **Cons**: This approach runs in multiple steps (one for each object copy), making it less efficient for this use-case than creating an object from an array in one go.

4. **Object Spread Syntax**:
   - **Test Case**: `let obj = {}; obj = { ...obj, ...{ a: 1 }}; obj = { ...obj, ...{ b: 2 }}; obj = { ...obj, ...{ c: 3 }};`
   - **Description**: The spread syntax (`...`) allows an iterable (like an array or object) to be expanded into a list of elements or properties. This syntax is also ES6 and provides a way to create new objects.
   - **Pros**: Clean syntax and can be used to easily merge multiple objects. It offers ease of use and improves readability.
   - **Cons**: Like `Object.assign`, it's less efficient for this specific task than using methods purpose-built for converting key-value pairs directly into an object.

### Benchmark Results Summary:
The benchmarks showed the performance in terms of executions per second for each method:

1. **Lodash fromPairs**: 33,016,350 executions/sec (fastest)
2. **Object.assign**: 24,553,392 executions/sec
3. **Object spread**: 15,465,021 executions/sec
4. **Object.fromEntries**: 11,046,887 executions/sec (slowest)

### Other Considerations:
- **Performance Differences**: Depending on the target environment, differences in execution speed can affect user experience and application responsiveness, particularly in scenarios where this transformation is done frequently or with large data sets.
- **Code Clarity vs. Performance**: Developers may choose methods based on code clarity and maintainability rather than raw performance. For example, `Object.fromEntries` is very readable, while `Object.assign` and spread syntax offer different advantages in contexts where merging properties is necessary.
- **Target Environment Compatibility**: Projects require consideration of compatibility; if the target environments include older browsers that do not support ES2019 features like `Object.fromEntries`, fallback methods may be necessary.

Overall, the choice of method will depend on performance needs, project requirements, and client/browser compatibility. For projects already using Lodash, using `_.fromPairs` may make sense, while in modern environments, `Object.fromEntries` provides a clear and efficient option.

Related benchmarks:

Object.fromEntries vs lodash fromPairs vs Object.assign vs Object spread (version: 1)

Comparing performance of: Object.fromEntries vs _.fromPairs vs Object.assign vs Object spread

Created: 8 days ago by: Guest

Jump to the latest result

Object.fromEntries

_.fromPairs

Object.assign

Object spread

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 8 days ago):