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>

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, i]; const value = 'value'+i; obj.set(key, {key, value}); }
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}); }
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);    
  }
}

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

 
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

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: 2 years 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

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

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:

Immutable Map: Uses the Immutable.js library to create an immutable map.
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.

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

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

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

Jump to the latest result

immutable Map

Native Javascript Map