Benchmark: immutable vs Native Javascript Map With Read Complex

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:

immutable Map
let obj = Immutable.Map(); for(i=0;i<10000;i++){ const key = ['key'+i, i]; const value = 'value'+i; obj.set(key, {key, value}); }
Native Javascript Map
let obj = new Map(); for(i=0;i<10000;i++){ const key = ['key'+i, i]; const value = 'value'+i; obj.set(key, {key, value}); }
Read immutable Map
let obj = Immutable.Map(); for(i=0;i<10000;i++){ const key = ['key'+i, i]; const value = 'value'+i; obj.set(key, {key, value}); } for(i=0;i<10000;i++){ const key = ['key'+i, i]; if (obj.has(key)) { const temp = obj.get(key); } }
Read Native Javascript Map
let obj = new Map(); for(i=0;i<10000;i++){ const key = ['key'+i, i]; const value = 'value'+i; obj.set(key, {key, value}) } for(i=0;i<10000;i++){ const key = ['key'+i, i]; if (obj.has(key)) { const temp = obj.get(key); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
immutable Map
Native Javascript Map
Read immutable Map
Read Native Javascript Map

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided benchmark measures the performance of two data structures: Immutable Maps and native JavaScript Maps, with additional scenarios for reading values from these maps. The goal is to compare the execution speed of these two approaches in different scenarios.

**Immutable Maps vs Native JavaScript Maps**

Both Immutable Maps and native JavaScript Maps are used as key-value stores in JavaScript. However, they have some differences:

* **Immutability**: Immutable Maps ensure that once a value is set, it cannot be modified. This comes at the cost of performance, as updating an immutable map requires creating a new one.
* **Native Performance**: Native JavaScript Maps are optimized for performance and can be modified in-place.

**Options Compared**

The benchmark compares two options:

1. **Immutable Map**: Uses the Immutable.js library to create an immutable map.
2. **Native JavaScript Map**: Creates a native JavaScript map without any additional libraries.

**Pros and Cons of Each Approach**

* **Immutable Map**:
	+ Pros: Ensures immutability, which can be beneficial for certain use cases (e.g., concurrent programming).
	+ Cons: Slower performance due to the overhead of creating new maps.
* **Native JavaScript Map**:
	+ Pros: Optimized for performance and allows in-place modification.
	+ Cons: Loses immutability, which may not be desirable in some situations.

**Additional Scenarios**

The benchmark also includes additional scenarios:

* **Read Immutable Map**: Measures the execution speed of reading values from an immutable map.
* **Read Native JavaScript Map**: Measures the execution speed of reading values from a native JavaScript map.

These additional scenarios help to further evaluate the performance characteristics of each approach, especially when it comes to accessing values in a map.

**Library: Immutable.js**

The Immutable.js library is used to create immutable maps. It provides a functional programming interface for creating and manipulating immutable data structures.

**Special JS Feature or Syntax: None**

There are no special JavaScript features or syntax used in this benchmark.

**Other Alternatives**

If you're interested in exploring alternative data structures, you might consider:

* **Native JavaScript Sets**: Similar to native JavaScript maps, but optimized for membership testing.
* **Other Immutable Libraries**: Other libraries like Lodash or Ramda provide immutable data structures and functional programming utilities.
* **Custom Data Structures**: Depending on your specific use case, you might want to create a custom data structure using a combination of native JavaScript and libraries.

Keep in mind that the choice of data structure ultimately depends on the requirements of your project.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 109 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
immutable Map	1424.0 Ops/sec
Native Javascript Map	717.8 Ops/sec
Read immutable Map	1073.0 Ops/sec
Read Native Javascript Map	445.0 Ops/sec

Related benchmarks:

immutable vs Native Javascript Map With Read Complex (version: 0)

immutable vs Native Javascript Map With Read

Comparing performance of: immutable Map vs Native Javascript Map vs Read immutable Map vs Read Native Javascript Map

Created: one year ago by: Guest

Jump to the latest result

immutable Map

Native Javascript Map

Read immutable Map

Read Native Javascript Map

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