Benchmark: Immutable.JS get vs object access vs map get

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>

Script Preparation code:

window.obj = {}
window.objImmutable = Immutable.Map();
window.map = new Map();

for(i=0;i<100;i++){
  const key = 'key'+i
  const value = 'value'+i
  window.obj[key] = value;
  window.objImmutable.set(key, value);
  window.map.set(key, value);
}

Tests:

Object property access
for(i=0;i<100;i++){ const key = 'key'+i window.obj[key] }
ImmutableJS get
for(i=0;i<100;i++){ const key = 'key'+i window.objImmutable.get(key); }
Map get
for(i=0;i<100;i++){ const key = 'key'+i window.map.get(key); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object property access
ImmutableJS get
Map get

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.57

Browser/OS: Chrome 113 on Windows

View result in a separate tab

Test name	Executions per second
Object property access	91719.9 Ops/sec
ImmutableJS get	125123.4 Ops/sec
Map get	123097.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmark test case on MeasureThat.net. The benchmark compares the performance of three different approaches: object property access, Immutable.js's `get` method, and Map's `get` method.

**What is being tested?**

In this benchmark, 100 objects are created with unique keys and values. Three methods are compared:

1. **Object Property Access**: Directly accessing an object property using the dot notation (`window.obj[key]`).
2. **Immutable.js Get**: Using Immutable.js's `get` method to retrieve a value from an Immutable Map (`window.objImmutable.get(key)`).
3. **Map Get**: Using the `get` method of a JavaScript Map (`window.map.get(key)`).

**Options compared**

The benchmark compares the performance of these three approaches in accessing and retrieving values from objects.

**Pros and Cons:**

1. **Object Property Access**:
	* Pros: Simple, straightforward access.
	* Cons: May involve additional memory allocation or reinitialization, leading to slower performance.
2. **Immutable.js Get**:
	* Pros: Provides a way to ensure data immutability, which can be beneficial for concurrent programming and predictable behavior.
	* Cons: Adds overhead due to the Immutable.js library, which may not be necessary for simple access scenarios.
3. **Map Get**:
	* Pros: Efficient use of memory, as Maps are designed to store key-value pairs efficiently.
	* Cons: May require additional object creation or lookup operations, potentially leading to slower performance.

**Library and its purpose**

1. **Immutable.js**: A JavaScript library that provides immutable data structures, ensuring predictable behavior and making it easier to reason about code.
2. **Map**: A built-in JavaScript data structure for storing key-value pairs efficiently.

**Special JS feature or syntax**

None mentioned in the provided benchmark definition. However, Immutable.js uses a functional programming paradigm, which may be unfamiliar to some developers.

**Alternative approaches**

Other alternatives could include:

1. Using a custom implementation of the `get` method using JavaScript's built-in `Object.prototype.hasOwnProperty.call()` and other methods.
2. Employing caching mechanisms or memoization techniques to reduce the number of lookups required.
3. Utilizing specialized libraries like `lru-cache` for efficient caching.

Keep in mind that the choice of approach depends on the specific use case, performance requirements, and personal preference.

Related benchmarks:

Immutable.JS get vs object access vs map get (version: 0)

Comparing performance of: Object property access vs ImmutableJS get vs Map get

Created: one year ago by: Guest

Jump to the latest result

Object property access

ImmutableJS get

Map get

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):