Benchmark: Immer (setAutoFreeze(false)) vs shallow vs ramda lens vs immutabe js vs immutable js (toJS) vs mutating

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/immer/8.0.1/immer.umd.production.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/immutable/3.8.2/immutable.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>

Script Preparation code:

var { compose, over, set, lensPath, append } = R

var INITIAL_DATA = { items: {}, count: 0, keys: [] }

for (var index = 0; index < 100; index++) {
  INITIAL_DATA[index] = { id: index, name: `ITEM-${index}`, value: Math.random() }
  INITIAL_DATA.count++
  INITIAL_DATA.keys.push(index)
}

var mutable = INITIAL_DATA

var NEW_ITEM_ID = INITIAL_DATA.count +1

var produce = immer.default
immer.setAutoFreeze(false)

var immutable = Immutable.fromJS(INITIAL_DATA)

Tests:

immer
data = produce(INITIAL_DATA, draft => { draft.items[NEW_ITEM_ID] = { id: NEW_ITEM_ID, name: 'ITEM-NEW', value: 0 } draft.counter++ draft.keys.push(NEW_ITEM_ID) })
shallow copy
data = { ...INITIAL_DATA, items: { ...INITIAL_DATA.items, [NEW_ITEM_ID]: { id: NEW_ITEM_ID, name: 'ITEM-NEW', value: 0 } }, count: INITIAL_DATA.count +1, keys: [ ...INITIAL_DATA.keys, NEW_ITEM_ID] }
ramda lens
data = compose( over(lensPath(["keys"]), append(NEW_ITEM_ID)), over(lensPath(["count"]), x => x + 1), set(lensPath(["items", NEW_ITEM_ID]), { id: NEW_ITEM_ID, name: "ITEM-NEW", value: 0 }) )(INITIAL_DATA);
Immutable js test
data = immutable.withMutations((state) => { state.update('items', items => items.set(NEW_ITEM_ID, { id: NEW_ITEM_ID, name: "ITEM-NEW", value: 0 })); state.set('count', INITIAL_DATA + 1); state.update('keys', keys => keys.push(NEW_ITEM_ID)); })
immutable js (toJS)
data = immutable.withMutations((state) => { state.update('items', items => items.set(NEW_ITEM_ID, { id: NEW_ITEM_ID, name: "ITEM-NEW", value: 0 })); state.set('count', INITIAL_DATA + 1); state.update('keys', keys => keys.push(NEW_ITEM_ID)); }) data.toJS()
mutate
mutable.items[NEW_ITEM_ID] = { id: NEW_ITEM_ID, name: 'ITEM-NEW', value: 0 } mutable.count = INITIAL_DATA.count +1 mutable.keys.push(NEW_ITEM_ID)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
immer
shallow copy
ramda lens
Immutable js test
immutable js (toJS)
mutate

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36

Browser/OS: Chrome 88 on Windows

View result in a separate tab

Test name	Executions per second
immer	6669.7 Ops/sec
shallow copy	704764.8 Ops/sec
ramda lens	48171.9 Ops/sec
Immutable js test	533626.5 Ops/sec
immutable js (toJS)	10588.5 Ops/sec
mutate	1512806.4 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a benchmarking test case created on MeasureThat.net, which compares the performance of different approaches to create and update immutable data structures in JavaScript.

**Approaches Compared**

The benchmark compares six different approaches:

1. **Immer (setAutoFreeze(false))**: Immer is a library that provides a simple and efficient way to work with immutable data structures. In this case, it's used without auto-freezing, which means the object will be frozen in place instead of being created as a new object.
2. **Shallow Copy**: A shallow copy creates a new object with references to the original object's properties. This approach is simple and lightweight but can lead to unexpected behavior if not used carefully.
3. **Ramda Lens**: Ramda Lens is a functional programming library that provides a way to manipulate data structures using lenses (functions that focus on specific parts of an object).
4. **Immutable.js (toJS)**: Immutable.js is a library that provides immutable data structures and utilities for working with them. The `toJS` method converts an immutable object to a regular JavaScript object.
5. **Immutable.js Test**: This approach uses the `withMutations` function from Immutable.js to update the immutable object. It's similar to the previous one but uses the `update` method instead of modifying the object directly.
6. **Mutate**: A simple mutation approach that modifies the original object directly.

**Pros and Cons of Each Approach**

Here are some pros and cons for each approach:

* **Immer (setAutoFreeze(false))**:
	+ Pros: Efficient, easy to use, and provides a good balance between performance and code simplicity.
	+ Cons: May not be suitable for very large datasets or complex data structures.
* **Shallow Copy**:
	+ Pros: Lightweight, simple, and easy to understand.
	+ Cons: Can lead to unexpected behavior if not used carefully, as it creates new references to the original object's properties.
* **Ramda Lens**:
	+ Pros: Provides a powerful way to manipulate data structures using functional programming principles.
	+ Cons: May be overkill for simple use cases and requires a good understanding of Ramda's API.
* **Immutable.js (toJS)**:
	+ Pros: Provides a safe and predictable way to work with immutable data structures.
	+ Cons: Can lead to slower performance compared to other approaches, as it involves creating new objects.
* **Immutable.js Test**:
	+ Pros: Similar to the previous approach but uses the `update` method instead of modifying the object directly.
	+ Cons: Still may be slower than other approaches due to the use of `withMutations`.
* **Mutate**:
	+ Pros: Simple and easy to understand, but may not be suitable for all use cases due to the direct modification of the original object.

**Benchmark Results**

The latest benchmark results show that:

* **Mutate**: The fastest approach with an average execution speed of 6.67 million operations per second.
* **Shallow Copy**: The next fastest approach with an average execution speed of 704,764 operations per second.
* **Immutable.js Test**: The slowest approach among the six, with an average execution speed of 53.3 million operations per second.

Keep in mind that these results are based on a specific JavaScript environment and may vary depending on your use case and requirements.

Related benchmarks:

Immer (setAutoFreeze(false)) vs shallow vs ramda lens vs immutabe js vs immutable js (toJS) vs mutating (version: 0)

Comparing performance of: immer vs shallow copy vs ramda lens vs Immutable js test vs immutable js (toJS) vs mutate

Created: 3 years ago by: Guest

Jump to the latest result

immer

shallow copy

ramda lens

Immutable js test

immutable js (toJS)

mutate

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):