Benchmark: immutable vs Native Javascript Map With Read Complex With Count

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

let count = 0;

for(i=0;i<10000;i++){
  const key = ['key'+i, i];
  if (obj.has(key)) {
    count++;
  	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});}​let count = 0;​for(i=0;i<10000;i++){  const key = ['key'+i, i];  if (obj.has(key)) {    count++;    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})
}

let count = 0;

for(i=0;i<10000;i++){
  const key = ['key'+i, i];
  if (obj.has(key)) {
    count++;
  	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})}​let count = 0;​for(i=0;i<10000;i++){  const key = ['key'+i, i];  if (obj.has(key)) {    count++;    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	1410.4 Ops/sec
Native Javascript Map	775.3 Ops/sec
Read immutable Map	1112.1 Ops/sec
Read Native Javascript Map	442.5 Ops/sec

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

Let's dive into the benchmark and explain what's being tested.

Benchmark Definition

The benchmark measures the performance of two approaches:

Immutable JavaScript Map: This approach uses the Immutable.js library to create an immutable map, where each operation (e.g., setting a key-value pair) creates a new map instance.
Native JavaScript Map: This approach uses the native JavaScript Map object, which is mutable.

Options Compared

The benchmark compares the following options:

Creating and populating an immutable map using Immutable.js
Creating and populating a native JavaScript map
Reading values from both types of maps (immutable and native)

Pros and Cons of Each Approach

Immutable JavaScript Map: Pros:
- Ensures data consistency by creating a new instance for each operation.
- Can provide better performance due to immutability.
Native JavaScript Map: Pros:
- Native implementation, which can be faster and more efficient.
- Often used in production code, so the results may reflect real-world usage.
Read operations:
- Immutable map: Provides a clear "has" operation, but may incur additional overhead due to the creation of new instances for each read.
- Native map: Offers an efficient "has" and "get" operation.

Library Used

The benchmark uses two libraries:

Immutable.js: A library that provides immutable data structures, ensuring thread-safety and providing a predictable API.
Immutability-helper: A small utility library that helps with functional programming and immutability in JavaScript.

Special JS Features or Syntax

None are mentioned explicitly in the provided benchmark definition.

Alternative Approaches

Other alternatives to consider when working with maps:

Object-oriented approach: Instead of using a map, you can use an object with key-value pairs.
Array-based approach: You can use arrays with Map instances or create your own custom data structure.

Keep in mind that these alternatives may have different trade-offs in terms of performance, memory usage, and code complexity. The choice ultimately depends on the specific requirements of your project.

In general, if you need to perform frequent reads or updates on a large dataset, using an immutable map or a native JavaScript map might be a good approach. However, if you prioritize data consistency and thread-safety, using Immutable.js might be a better fit.

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark measures the performance of two approaches:

1. **Immutable JavaScript Map**: This approach uses the Immutable.js library to create an immutable map, where each operation (e.g., setting a key-value pair) creates a new map instance.
2. **Native JavaScript Map**: This approach uses the native JavaScript `Map` object, which is mutable.

**Options Compared**

The benchmark compares the following options:

* Creating and populating an immutable map using Immutable.js
* Creating and populating a native JavaScript map
* Reading values from both types of maps (immutable and native)

**Pros and Cons of Each Approach**

1. **Immutable JavaScript Map**: Pros:
	* Ensures data consistency by creating a new instance for each operation.
	* Can provide better performance due to immutability.
2. **Native JavaScript Map**: Pros:
	* Native implementation, which can be faster and more efficient.
	* Often used in production code, so the results may reflect real-world usage.
3. **Read operations**:
	* Immutable map: Provides a clear "has" operation, but may incur additional overhead due to the creation of new instances for each read.
	* Native map: Offers an efficient "has" and "get" operation.

**Library Used**

The benchmark uses two libraries:

1. **Immutable.js**: A library that provides immutable data structures, ensuring thread-safety and providing a predictable API.
2. **Immutability-helper**: A small utility library that helps with functional programming and immutability in JavaScript.

**Special JS Features or Syntax**

None are mentioned explicitly in the provided benchmark definition.

**Alternative Approaches**

Other alternatives to consider when working with maps:

1. **Object-oriented approach**: Instead of using a map, you can use an object with key-value pairs.
2. **Array-based approach**: You can use arrays with `Map` instances or create your own custom data structure.

Related benchmarks:

immutable vs Native Javascript Map With Read Complex With Count (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