Benchmark: Immer vs Shallow copy vs Immutable Perf Test 3 (update library version)

HTML Preparation code:

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

Script Preparation code:

//const { fromJS } = require('immutable');
var data = { items: {}, count: 0, keys: [] }

for (let index = 0; index < 100; index++) {
  data[index] = { id: index, name: `ITEM-${index}`, value: Math.random() }
  data.count++
  data.keys.push(index)
}

var NEW_ITEM_ID = data.count +1

var produce = immer.default

var im = Immutable.fromJS(data);

Tests:

immer
data = produce(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 = { ...data, items: { ...data.items, [NEW_ITEM_ID]: { id: NEW_ITEM_ID, name: 'ITEM-NEW', value: 0 } }, count: data.count +1, keys: [ ...data.keys, NEW_ITEM_ID] }
Immutable
var um = im.set('items', im.get('items').set(NEW_ITEM_ID, { id: NEW_ITEM_ID, name: 'ITEM-NEW', value: 0 })); um = um.set('count', um.count +1); um = um.set('keys', um.get('keys').push(NEW_ITEM_ID));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
immer
shallow copy
Immutable

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down what's being tested in this benchmark and explain the different approaches, their pros and cons, and other considerations.

**Overview**

The benchmark is testing three approaches for creating immutable data structures:

1. Immer (by Jim Schertler): a library for functional programming in JavaScript.
2. Shallow copy: a simple assignment operation that creates a new object with references to the original data.
3. Immutable: another approach that uses ES6 syntax to create an immutable object.

**Immer**

The first test case uses Immer's `produce` function to create a new, immutable object from the original data. The `produce` function takes two arguments:

* `data`: the original data
* `draft => { ... }`: a callback function that defines how the data should be updated

In this case, the callback function adds a new item to the `items` array and increments the `count` property.

Pros:

* Immer provides a way to create immutable objects in a functional programming style.
* It can help prevent unexpected side effects by ensuring that the original data remains unchanged.

Cons:

* Immer requires an additional library to be included in the test environment (immediate mode).
* The callback function can make the code harder to read and understand for some developers.

**Shallow Copy**

The second test case uses a simple assignment operation to create a new object with references to the original data. This approach is essentially just copying the entire `data` object without any modifications.

Pros:

* It's easy to implement and doesn't require any additional libraries.
* It can be faster than Immer because it doesn't involve creating a new object graph.

Cons:

* Shallow copy does not create immutable objects, which means that if multiple parts of the code modify the same data, unintended side effects can occur.
* If the original data contains references to other objects, modifying those objects will also affect the copied data.

**Immutable**

The third test case uses ES6 syntax to create an immutable object. This approach is similar to Immer's `produce` function but uses a more concise syntax.

Pros:

* It provides a way to create immutable objects with a simpler syntax than Immer.
* It can help prevent unexpected side effects by ensuring that the original data remains unchanged.

Cons:

* Like Shallow Copy, Immutable does not create true immutable objects if multiple parts of the code modify the same data.
* The syntax is specific to ES6 and may not work in older JavaScript environments.

**Other Considerations**

* Performance: The benchmark measures the number of executions per second for each approach. Immer's `produce` function appears to be the slowest, while Shallow Copy is the fastest but also creates non-immutable objects.
* Code readability and maintainability: While Immer provides a functional programming style, the callback function can make the code harder to understand. Immutable's syntax is more concise, but it may not be familiar to all developers.
* Library dependencies: The benchmark includes separate libraries for each approach (Immer, Shallow Copy, and Immutable), which can affect performance and maintainability.

**Alternatives**

Some alternative approaches for creating immutable data structures include:

* Using a library like Lodash or Underscore.js, which provide functional programming utilities.
* Creating an immutable data structure using a class-based approach (e.g., `class ImmutableData { ... }`).
* Using a functional programming language like Haskell or Scala, which have built-in support for immutable data structures.

These alternatives may offer different trade-offs in terms of performance, code readability, and maintainability.

Latest run results:

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

User agent: Mozilla/5.0 (X11; CrOS x86_64 14961.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36

Browser/OS: Chrome 105 on Chrome OS 14961.0.0

View result in a separate tab

Test name	Executions per second
immer	1263.3 Ops/sec
shallow copy	5778.4 Ops/sec
Immutable	451426.6 Ops/sec

Related benchmarks:

Immer vs Shallow copy vs Immutable Perf Test 3 (update library version) (version: 0)

Comparing performance of: immer vs shallow copy vs Immutable

Created: 4 years ago by: Registered User

Jump to the latest result

immer

shallow copy

Immutable

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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