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>

AخA
 
<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}); }
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}); }
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);    
  }
}

​x
 
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);    
  }
}

 
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
immutable Map	1750.8 Ops/sec
Native Javascript Map	819.5 Ops/sec
Read immutable Map	1058.9 Ops/sec
Read Native Javascript Map	624.4 Ops/sec

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

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:

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

Pros and Cons

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.
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

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

Other Immutable Libraries: Other libraries like Lodash Immutability Helper or js-immutable can be used instead of Immutable.js.
Native Alternatives: Other native JavaScript data structures like WeakMap or Map with a custom implementation could be used as alternatives to native Maps.
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.

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.

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: 2 years ago by: Guest

Jump to the latest result

immutable Map

Native Javascript Map