Benchmark: Builder pattern extend

HTML Preparation code:

<script src='https://cdn.jsdelivr.net/npm/builder-pattern@2.2.0/dist/index.min.js'></script>

Script Preparation code:

const defaultUserInfo = {
    id: 1,
    userName: 'foo',
    email: 'foo@bar.baz'
};

Tests:

Build
const modifiedUserInfo = Builder(defaultUserInfo) .id(2) .build();
Spread
const modifiedUserInfo = {...defaultUserInfo, id: 2};
Object.assign
const modifiedUserInfo = Object.assign({}, defaultUserInfo, {id: 2});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Build
Spread
Object.assign

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated yesterday):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON is focused on evaluating different methods for constructing an object (specifically user information) in JavaScript. This is particularly relevant for software engineers dealing with object creation and management, as it allows them to assess the performance implications of various approaches.

### Options Compared

1. **Builder Pattern**: 
   - **Code**: `const modifiedUserInfo = Builder(defaultUserInfo).id(2).build();`
   - **Test Name**: Build
   - **Library**: This method uses the "builder-pattern" library, which provides a fluent interface for constructing and configuring objects step-by-step. The Builder pattern is generally useful for creating complex objects without having to pass multiple parameters to a constructor.

2. **Spread Operator**:
   - **Code**: `const modifiedUserInfo = {...defaultUserInfo, id: 2};`
   - **Test Name**: Spread
   - The spread operator (`...`) allows for easy copying and merging of properties from existing objects. It is a JavaScript feature that simplifies the merging of object properties into a new object.

3. **Object.assign**:
   - **Code**: `const modifiedUserInfo = Object.assign({}, defaultUserInfo, {id: 2});`
   - **Test Name**: Object.assign
   - This method uses the `Object.assign()` function, which copies the values of all enumerable own properties from one or more source objects to a target object.

### Performance Results
From the benchmark results, we can see the following execution speeds:

- **Spread**: 7,102,648.5 executions per second
- **Object.assign**: 2,679,095.25 executions per second
- **Builder Pattern**: 1,954,529.75 executions per second

### Pros/Cons of Each Approach

1. **Builder Pattern**:
   - **Pros**:
     - Readable and fluent syntax improves maintainability.
     - Ideal for constructing complex objects step-by-step.
   - **Cons**:
     - Additional overhead from using an external library.
     - Generally slower in performance compared to native methods.

2. **Spread Operator**:
   - **Pros**:
     - Very concise and expressive.
     - Provides immutability by returning a new object.
     - Generally the fastest approach based on benchmark results.
   - **Cons**:
     - Can lead to shallow copies, which may not be suitable for nested objects without additional handling.

3. **Object.assign**:
   - **Pros**:
     - Useful for merging multiple objects into one.
     - Works well with existing objects, providing flexibility.
   - **Cons**:
     - Also creates a shallow copy, which means nested objects may cause unexpected behavior.
     - Slightly slower performance compared to the spread operator.

### Other Considerations
- **Immutability**: Both the spread operator and `Object.assign` create new objects, promoting immutability, which is a valuable practice in functional programming paradigms. The Builder pattern may or may not enforce immutability depending on its implementation.
- **Syntax Familiarity**: Depending on the developer's familiarity with ES6+ features, usage of the spread operator may be preferred over `Object.assign`.
- **Complex Object Configuration**: For cases involving very complex configurations, the Builder Pattern might be more favorable despite its performance trade-offs.

### Alternatives
Other methods for creating and manipulating objects could include using prototypes or class syntax introduced in ES6 for structuring object factories. Furthermore, libraries like Lodash offer utilities that can also manage object creation and merging effectively.

In conclusion, the benchmark highlights how different JavaScript approaches can yield significant differences in performance, making it crucial for developers to select the most efficient method based on their specific use case and requirements.

Latest run results:

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

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

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Build	1954529.8 Ops/sec
Spread	7102648.5 Ops/sec
Object.assign	2679095.2 Ops/sec

Related benchmarks:

Builder pattern extend (version: 1)

Comparing performance of: Build vs Spread vs Object.assign

Created: 2 days ago by: Guest

Jump to the latest result

Build

Spread

Object.assign

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated yesterday):