Benchmark: Get object from map in Map, Object and map in WeakMap

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

let o, m, w, owm;
const map = new Map();
const obj = Object.create(null);
const wm  = new WeakMap();
const wm2  = new WeakMap();
const objSet = (ob, k, v)=>{
  ob[k] = v;
  return ob;
};
let data = Object.create(null);
wm.set(data, new Map());
wm2.set(data, Object.create(null));

for (let i = 65; i < 90; i++) {
  let t = String.fromCharCode(i);
  obj[t] = i;
  map.set(t, i);
  wm.set(data, (wm.get(data)).set(t, i));
  wm2.set(data, objSet(wm2.get(data), t, i));
}

Tests:

Object
o = obj['M'];
Map
m = map.get('M');
Map in WeakMap
w = wm.get(data).get('M');
Object in WeakMap
owm = wm2.get(data)['M'];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object
Map
Map in WeakMap
Object in WeakMap

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 months ago)

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

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
Object	8553419.0 Ops/sec
Map	8156600.0 Ops/sec
Map in WeakMap	7180517.0 Ops/sec
Object in WeakMap	7575181.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON tests the performance of four different data access methods within JavaScript: accessing properties from an object, retrieving values from a JavaScript `Map`, and fetching values from two types of `WeakMap`, one containing a `Map` and another containing a plain object. Each method is executed multiple times, and the results are measured in terms of executions per second.

### Comparison of Tested Approaches

1. **Object Access (`o = obj['M'];`)**
   - **Description**: Accessing a property directly from a standard JavaScript object.
   - **Pros**: Fast retrieval because standard objects are optimized for property access. Direct property access is straightforward and requires no additional structure.
   - **Cons**: Objects can only store string keys (or symbols). If the key is not found, it can lead to performance issues if used incorrectly.

2. **Map Access (`m = map.get('M');`)**
   - **Description**: Accessing a value from a `Map`. Maps are a more flexible key-value store and can handle various data types as keys.
   - **Pros**: Maps maintain the order of their elements and allow non-string keys. This provides better performance in scenarios with frequent additions and deletions compared to objects.
   - **Cons**: Slightly slower access times when compared to direct object property access due to the underlying implementation of `Map`.

3. **Map in WeakMap (`w = wm.get(data).get('M');`)**
   - **Description**: Accessing a value from a `Map` that is stored within a `WeakMap`. A `WeakMap` introduces memory safety since the keys are weakly held, allowing for garbage collection.
   - **Pros**: Using `WeakMap` prevents memory leaks in long-lived applications where the existence of keys should not prevent garbage collection (i.e., when the key object is no longer reachable).
   - **Cons**: Accessing a value in a nested `Map` increases complexity and can affect performance due to multiple lookups (first in `WeakMap`, then in the nested `Map`).

4. **Object in WeakMap (`owm = wm2.get(data)['M'];`)**
   - **Description**: Accessing a property from a plain object that is stored within a `WeakMap`.
   - **Pros**: Similar to the above, you benefit from the memory safety of `WeakMap`. The direct object property access is quick once you retrieve the object.
   - **Cons**: Additionally involves navigating through the `WeakMap`, making it more complex to access the property compared to a straightforward object access.

### Benchmark Results Analysis

The results show the following executions per second for each test:
- **Object**: 8,128,027.5 operations
- **Map**: 8,081,464.0 operations
- **Object in WeakMap**: 7,181,478.5 operations
- **Map in WeakMap**: 7,112,241.5 operations

**Observations**:
- Accessing properties from standard objects is the fastest, followed closely by `Map`.
- Accessing values within `WeakMap` structures, whether they contain an object or a `Map`, results in decreased performance due to the additional layer of indirection required to reach the desired value.

### Alternatives and Other Considerations

- **Plain Objects vs. Maps**: When deciding to use objects or maps, consider the key type requirements and the performance needs for frequent operations. Use `Map` for dynamic key scenarios and maintain order.
- **Using Proxy**: If you require dynamic property handling or want to intercept property access, using a `Proxy` may be viable, impacting performance differently based on implementation.
- **Set**: For scenarios where you only need to store unique values without associations, `Set` can be paired appropriately with `WeakMap`.

Overall, while different approaches have their own pros and cons, the choice depends on the specific use case requirements around memory management, key types, property access patterns, and performance metrics.

Related benchmarks:

Get object from map in Map, Object and map in WeakMap (version: 1)

Comparing performance of: Object vs Map vs Map in WeakMap vs Object in WeakMap

Created: 2 months ago by: Registered User

Jump to the latest result

Object

Map

Map in WeakMap

Object in WeakMap

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):