Benchmark: object spread vs immutable-js set (large)

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/immutable/3.8.2/immutable.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/immutability-helper@2.7.0/index.min.js"></script>

Tests:

object spread
let obj = {}; for(i=0;i<10000;i++){ const key = 'key'+i const value = 'value'+i obj = {...obj, [key]: {key, value}} }
immutable-js
let obj = Immutable.Map(); for(i=0;i<10000;i++){ const key = 'key'+i const value = 'value'+i obj = obj.set(key, {key, value}) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
object spread
immutable-js

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 years ago)

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

Browser/OS: Chrome 81 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
object spread	0.0 Ops/sec
immutable-js	181.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript object manipulation techniques can be a complex task.

The provided JSON benchmark definition tests two approaches for updating an object:

1. **Object Spread**: This method uses the spread operator (`{...obj, [key]: {key, value}}`) to create a new object with the updated key-value pair.
2. **Immutable-js Set**: This method uses the `Immutable.js` library to update a Map object with the added key-value pair.

**Options Comparison:**

*   **Object Spread (using spread operator)**

Pros:

*   Easy to implement and read
    *   Works well for small objects or simple updates
    *   Less memory overhead compared to Immutable.js
    *   Native JavaScript support, so no additional library dependency is needed

Cons:

*   Performance can degrade with large objects due to the creation of a new object on each update.
    *   May not be suitable for concurrent updates or complex object manipulation.

*   **Immutable-js Set (using Immutable.js library)**

Pros:

*   Provides a predictable and consistent performance due to the immutability of Map objects.
    *   Suitable for large objects, concurrent updates, and complex object manipulation.
    *   Reduces memory leaks associated with updating mutable objects.

Cons:

*   Requires additional dependency on the Immutable.js library.
    *   Can introduce overhead due to the use of a third-party library.

**Library Overview:**

The `Immutable.js` library provides a way to work with immutable data structures, such as Maps and Sets. The `immutability-helper` library is used in conjunction with Immutable.js for additional helper functions. These libraries aim to make working with immutable data more efficient and easier to manage.

**Special JS Feature/Syntax:**

In this benchmark, the use of spread operator (`{...obj, [key]: {key, value}}`) is a notable feature. This syntax was introduced in ECMAScript 2018 (ES8) as part of the standard specification for JavaScript object spreading and merging. The spread operator allows for creating new objects by copying properties from an existing object.

**Alternatives:**

Alternative approaches to updating objects include:

1.  **Array.prototype.push() + Object.assign():**

This method uses `Array.prototype.push()` to add elements to an array, followed by `Object.assign()` to update the entire array with the new key-value pair.
2.  **Object.create() + assignment:**

This method uses `Object.create()` to create a new object and then assigns values to it using dot notation or bracket notation (`obj[key] = value`).
3.  **Using for...of loop with Object.keys():**

This method uses a `for...of` loop to iterate over the keys of an object, assigning values to them.

Each of these alternatives has its own trade-offs in terms of performance and readability.

Related benchmarks:

object spread vs immutable-js set (large) (version: 0)

Comparing performance of: object spread vs immutable-js

Created: 4 years ago by: Guest

Jump to the latest result

object spread

immutable-js

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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