Benchmark: immutable vs Native Javascript Map With Read

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; 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; 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; const value = 'value'+i; obj.set(key, {key, value}); } for(i=0;i<10000;i++){ const key = 'key'+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; const value = 'value'+i; obj.set(key, {key, value}) } for(i=0;i<10000;i++){ const key = 'key'+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 one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

**Benchmark Definition**

The benchmark measures the performance of two approaches: using Immutable.js and native JavaScript Maps for storing and retrieving data.

**Options Compared**

There are four test cases:

1. **Immutable Map**: Uses Immutable.js to create a map, which is an immutable data structure.
2. **Native Javascript Map**: Creates a native JavaScript Map object without any additional library or framework.
3. **Read immutable Map**: Retrieves data from the Immutable Map using the `get` method.
4. **Read Native Javascript Map**: Retrieves data from the native JavaScript Map using the `get` method.

**Pros and Cons**

1. **Immutable Map**
	* Pros: Immutable data structure provides thread safety and ensures data consistency. Immutable.js is a popular library for working with immutable data in JavaScript.
	* Cons: Additional overhead due to immutability, which can impact performance. Immutable.js is also an external dependency that needs to be included in the benchmark.
2. **Native Javascript Map**
	* Pros: Lightweight and fast, as it's a native JavaScript object. No additional overhead or dependencies.
	* Cons: Mutable data structure means potential for concurrency issues and data inconsistencies.

**Library Used**

1. **Immutable.js**: A popular library for working with immutable data in JavaScript. It provides a rich set of functions for creating, manipulating, and transforming immutable data structures.

**Special JS Feature/Syntax**

None mentioned in the provided benchmark definition.

**Other Considerations**

* The benchmark measures the performance of both reading from and writing to the maps, which can impact the results.
* The test cases use a simple key-value pair structure, but more complex scenarios (e.g., nested objects, arrays) may yield different results.
* The benchmark uses Chrome 109 as the browser, which might not be representative of other browsers or environments.

**Alternatives**

1. **Other Immutable Libraries**: Other libraries like Lodash Immutability Helper or js-immutable can be used instead of Immutable.js.
2. **Native Alternatives**: Other native JavaScript data structures like WeakMap or Map with a custom implementation could be used as alternatives to native Maps.
3. **Different Browsers or Environments**: Running the benchmark on other browsers or environments (e.g., Node.js, Safari) may yield different results due to differences in execution speed and behavior.

Keep in mind that these considerations are specific to this particular benchmark, and the choice of approach ultimately depends on the use case and requirements.

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	1378.9 Ops/sec
Native Javascript Map	602.1 Ops/sec
Read immutable Map	1247.8 Ops/sec
Read Native Javascript Map	387.2 Ops/sec

Related benchmarks:

immutable vs Native Javascript Map With Read (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 one month ago):