Benchmark: Object.fromEntries vs lodash fromPairs vs Object.assign vs Object spread with custom func

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 addonDefinitions = { a: 1, b: 2, c: 3 }; var definitionsTupleArray = []; Object.entries(addonDefinitions).forEach(([definitionId, definition]) => { definitionsTupleArray.push([definitionId, definition]); }); var b = _.fromPairs(definitionsTupleArray);
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	9002239.0 Ops/sec
_.fromPairs	6755774.5 Ops/sec
Object.assign	19589822.0 Ops/sec
Object spread	14817065.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark you provided compares the performance of four different methods for creating objects from arrays of key-value pairs in JavaScript. Here's a breakdown of each method included in the benchmark, their pros and cons, and any relevant libraries or features:

### 1. **Object.fromEntries()**
- **Test Name:** Object.fromEntries
- **Benchmark Definition:** `var a = [['a', 1], ['b', 2], ['c', 3]]; var b = Object.fromEntries(a);`
- **Description:** This built-in method converts a list of key-value pairs (in the form of an array of tuples) into an object.
- **Pros:**
  - Simple and concise syntax.
  - Native support in JavaScript (ES2019).
  - Optimized performance as it is a built-in function.
- **Cons:**
  - Limited to key-value pairs provided in the input array format.
  
### 2. **Lodash fromPairs**
- **Test Name:** _.fromPairs
- **Benchmark Definition:** 
    ```javascript
    var addonDefinitions = { a: 1, b: 2, c: 3 };
    var definitionsTupleArray = [];
    Object.entries(addonDefinitions).forEach(([definitionId, definition]) => {
        definitionsTupleArray.push([definitionId, definition]);
    });
    var b = _.fromPairs(definitionsTupleArray);
    ```
- **Library Used:** **Lodash**
  - **Purpose:** Lodash is a utility library that provides helpful functions for common programming tasks, such as manipulating arrays, numbers, objects, strings, etc. The `fromPairs` function converts an array of key-value pair arrays into an object.
- **Pros:**
  - Offers several utility methods in one library, enhancing versatility.
- **Cons:**
  - Additional overhead from loading the Lodash library.
  - Slightly more complex syntax compared to `Object.fromEntries()` for this specific case.

### 3. **Object.assign()**
- **Test Name:** Object.assign
- **Benchmark Definition:**
    ```javascript
    var obj = {};
    Object.assign(obj, { a: 1 });
    Object.assign(obj, { b: 2 });
    Object.assign(obj, { c: 3 });
    ```
- **Description:** The `Object.assign()` method copies all enumerable own properties from one or more source objects to a target object. It is often used for merging objects.
- **Pros:**
  - Can be used to merge multiple source objects.
  - Simple for combining properties from multiple sources.
- **Cons:**
  - Requires multiple calls for each key-value pair.
  - Mutates the target object; not functional in nature.

### 4. **Object Spread Operator**
- **Test Name:** Object spread
- **Benchmark Definition:**
    ```javascript
    let obj = {};
    obj = { ...obj, ...{ a: 1 }};
    obj = { ...obj, ...{ b: 2 }};
    obj = { ...obj, ...{ c: 3 }};
    ```
- **Description:** The spread operator (`...`) allows for the expansion of an array or object. In this case, it is being used to create a new object by adding properties.
- **Pros:**
  - Concise and elegant syntax.
  - Does not mutate the original object, promoting immutability.
- **Cons:**
  - Requires more syntax and can lead to performance overhead due to the creation of additional objects in each iteration.

### Benchmark Results
According to the latest results:
- **Object.assign:** ~19.6 million executions per second (fastest)
- **Object spread:** ~14.8 million executions per second
- **Object.fromEntries:** ~9.0 million executions per second
- **_.fromPairs:** ~6.8 million executions per second (slowest)

### Other Considerations
- **Performance:** When choosing an approach, performance can be a key factor. The results show that `Object.assign` was the fastest, followed by the spread operator. However, for clarity and maintainability, the choice may also depend on the specific use case and the desired balance between speed and code readability.
- **Dependencies:** Using Lodash adds a dependency to your project which needs to be managed. In contrast, using native JavaScript methods may reduce overall project complexity.
- **Readability:** The choice of method might also depend on the team's familiarity with the syntax and the necessary readability for current and future developers in a project.

In summary, while there are multiple approaches to create objects from arrays of key-value pairs, the appropriate method can depend on factors such as readability, performance, and the specific needs of your application.

Related benchmarks:

Object.fromEntries vs lodash fromPairs vs Object.assign vs Object spread with custom func (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):