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>

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

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

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	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 2 months ago):

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.

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.

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: 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 2 months ago):