Benchmark: Immutable Map vs Ordered Map vs List

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/immutable/3.8.2/immutable.min.js"></script>

AخA
 
<script src="https://cdnjs.cloudflare.com/ajax/libs/immutable/3.8.2/immutable.min.js"></script>

Script Preparation code:

var max = 10000000;
var array = [];
for (var i = 0; i < max; i++) {
    array.push({
        id: i
    });
}

 
var max = 10000000;var array = [];for (var i = 0; i < max; i++) {    array.push({        id: i    });}

Tests:

Map

var result = Immutable.Map().asMutable();
for (var i = 0; i < array.lengh; i++) {
  result.set(array[i].id, array[i])
}
return result.asImmutable();

 
var result = Immutable.Map().asMutable();for (var i = 0; i < array.lengh; i++) {  result.set(array[i].id, array[i])}return result.asImmutable();

OrderedMap

var result = Immutable.OrderedMap().asMutable();
for (var i = 0; i < array.lengh; i++) {
  result.set(array[i].id, array[i])
}
return result.asImmutable();

 
var result = Immutable.OrderedMap().asMutable();for (var i = 0; i < array.lengh; i++) {  result.set(array[i].id, array[i])}return result.asImmutable();

List

var result = Immutable.List().asMutable();
for (var i = 0; i < array.lengh; i++) {
  result.push(array[i])
}
return result.asImmutable();

 
var result = Immutable.List().asMutable();for (var i = 0; i < array.lengh; i++) {  result.push(array[i])}return result.asImmutable();

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
Map
OrderedMap
List

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 years ago)

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

Browser/OS: Chrome 81 on Mac OS X 10.15.4

View result in a separate tab

Test name	Executions per second
Map	4420915.5 Ops/sec
OrderedMap	3515042.0 Ops/sec
List	3759088.2 Ops/sec

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

Benchmark Overview

The provided JSON represents a JavaScript benchmarking test created using MeasureThat.net. The test compares the performance of three data structures: Immutable Map, Ordered Map, and List.

Options Compared

The benchmark tests the execution speed of each data structure when:

Creating an instance of the data structure.
Iterating over the data structure and setting values (in the case of Map and Ordered Map).
Iterating over the data structure and appending values (in the case of List).

Pros and Cons of Each Approach

Immutable Map
- Pros: Immutable data structures are thread-safe, and they provide a clear contract for concurrent access.
- Cons: Creating an instance of an immutable map is slower than creating an instance of a mutable data structure like an Array or Object.
Ordered Map
- Pros: Ordered maps preserve the insertion order of elements, making them useful for applications that require maintaining a specific order.
- Cons: Ordered maps are less efficient than immutable maps and can be slower due to the need to maintain the insertion order.
List
- Pros: Lists are mutable, which makes them easy to work with in many scenarios. They also provide an efficient way to append elements.
- Cons: Lists do not preserve the insertion order of elements.

Libraries and Their Purpose

In the benchmark preparation code, two libraries are imported:

Immutable: A JavaScript library for creating immutable data structures. Immutable maps and ordered maps are used in this benchmark, which provides thread-safe and predictable behavior.
No additional libraries are mentioned in the provided test cases, but it's likely that other libraries (e.g., jQuery) might be used in the actual application code.

Special JS Features or Syntax

There is no special JavaScript feature or syntax mentioned in the provided benchmark code. The focus is on testing the performance of three data structures without using any advanced features like async/await, Promises, or Closures.

Other Alternatives

If you're interested in exploring alternative data structures for this use case, consider the following options:

Mutable Maps: Use an Object (or a Map implementation) instead of Immutable maps. This approach would provide faster execution times but might not be suitable for concurrent access.
Ordered Data Structures: Explore other ordered data structures like trees or graphs. These alternatives might offer better performance in certain scenarios, especially when dealing with large datasets.

Keep in mind that the choice of data structure depends on the specific requirements and constraints of your application. Always consider factors like thread-safety, predictability, and performance characteristics when selecting a data structure.

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript benchmarking test created using MeasureThat.net. The test compares the performance of three data structures: Immutable Map, Ordered Map, and List.

**Options Compared**

The benchmark tests the execution speed of each data structure when:

1. Creating an instance of the data structure.
2. Iterating over the data structure and setting values (in the case of Map and Ordered Map).
3. Iterating over the data structure and appending values (in the case of List).

**Pros and Cons of Each Approach**

1. **Immutable Map**
	* Pros: Immutable data structures are thread-safe, and they provide a clear contract for concurrent access.
	* Cons: Creating an instance of an immutable map is slower than creating an instance of a mutable data structure like an Array or Object.
2. **Ordered Map**
	* Pros: Ordered maps preserve the insertion order of elements, making them useful for applications that require maintaining a specific order.
	* Cons: Ordered maps are less efficient than immutable maps and can be slower due to the need to maintain the insertion order.
3. **List**
	* Pros: Lists are mutable, which makes them easy to work with in many scenarios. They also provide an efficient way to append elements.
	* Cons: Lists do not preserve the insertion order of elements.

**Libraries and Their Purpose**

In the benchmark preparation code, two libraries are imported:

1. **Immutable**: A JavaScript library for creating immutable data structures. Immutable maps and ordered maps are used in this benchmark, which provides thread-safe and predictable behavior.
2. No additional libraries are mentioned in the provided test cases, but it's likely that other libraries (e.g., jQuery) might be used in the actual application code.

**Special JS Features or Syntax**

**Other Alternatives**

If you're interested in exploring alternative data structures for this use case, consider the following options:

1. **Mutable Maps**: Use an Object (or a Map implementation) instead of Immutable maps. This approach would provide faster execution times but might not be suitable for concurrent access.
2. **Ordered Data Structures**: Explore other ordered data structures like trees or graphs. These alternatives might offer better performance in certain scenarios, especially when dealing with large datasets.

Related benchmarks:

Immutable Map vs Ordered Map vs List (version: 0)

Comparing performance of: Map vs OrderedMap vs List

Created: 4 years ago by: Guest

Jump to the latest result

Map