Benchmark: Map vs Object (real-world) Performance with string keys

Script Preparation code:

var keyCount = 16384
var keys = []
var map = new Map()
var obj = {}
var result = 0


// Hide lookup keys to prevent V8 cheating (AKA Optimizing)
var getConspicuousKey = seed => keys[Math.floor(seed * keyCount)]


// Setup out test objects w/ random values
for (let i=0; i<keyCount; i++) {
  let val = "_" + Math.random()
  let key = "_" + Math.random()
  keys.push(key)
  map.set(key,val)
  obj[key] = val
}

Tests:

Conspicuous Map lookup
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) let val = map.get(key) result += +val[1] > 5 ? 1 : -1 }
Conspicuous Obj lookup
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) let val = obj[key] result += +val[1] > 5 ? 1 : -1 }
Conspicuous Map lookup 2
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) let val = map.get(key) result += +val[1] > 5 ? 1 : -1 }
Conspicuous Obj lookup 2
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) let val = obj[key] result += +val[1] > 5 ? 1 : -1 }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Conspicuous Map lookup
Conspicuous Obj lookup
Conspicuous Map lookup 2
Conspicuous Obj lookup 2

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36

Browser/OS: Chrome 132 on Linux

View result in a separate tab

Test name	Executions per second
Conspicuous Map lookup	503.0 Ops/sec
Conspicuous Obj lookup	591.7 Ops/sec
Conspicuous Map lookup 2	503.6 Ops/sec
Conspicuous Obj lookup 2	594.4 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark presented tests performance differences between JavaScript `Map` and standard JavaScript `Object` for string key lookups in a real-world context. The overall goal is to determine which of these data structures performs better under specific conditions.

### Comparison of Options

1. **JavaScript Objects**:
   - **Use Case**: Traditionally used as simple key-value stores where the keys are strings (or Symbols).
   - **Performance**: It can be faster for simple key-value pairs, especially when used for fewer keys or when using known keys due to optimizations by the JavaScript engine.
   - **Pros**:
     - Simpler syntax and well-integrated in the language.
     - Less overhead compared to `Map` for relatively few properties.
   - **Cons**:
     - Performance can degrade significantly with a large number of keys or non-string keys (as they can cause coercion).
     - Key enumeration order is not guaranteed, which can lead to unexpected behaviors in some scenarios.

2. **JavaScript Maps**:
   - **Use Case**: Designed to handle key-value pairs where keys can be any data type (including objects) and maintain the insertion order.
   - **Performance**: Generally optimized for scenarios involving numerous items (especially when keys are not just strings). The `Map` allows for faster lookups.
   - **Pros**:
     - Better performance with larger datasets and complex key types.
     - Maintains the insertion order of keys and offers richer iteration capabilities.
   - **Cons**:
     - Slightly higher memory overhead compared to a simple object.
     - Additional syntax when setting/getting values (e.g., using `.set()` and `.get()` instead of direct assignment).

### Benchmarking Structure

The benchmark specifically tests lookup performance by simulating scenarios with 16,384 string keys. Each test involves:

1. Using `Math.random()` to select a random key from the original set (this helps avoid engine optimizations).
2. Looking up a value associated with that key in either a `Map` or an `Object`.
3. Summing up results based on a condition derived from the retrieved value.

### Test Cases

Four test cases are defined, comparing the lookup times for each:

1. **Conspicuous Map Lookup**: Measures the performance of looking up keys in a `Map`.
2. **Conspicuous Object Lookup**: Measures the performance of looking up keys in a standard `Object`.
3. **Conspicuous Map Lookup 2**: A second pass of looking up in a `Map`, likely for consistency checking or additional metrics.
4. **Conspicuous Object Lookup 2**: A second pass for `Object` lookups, similarly meant for deeper insights.

By executing these test cases in the given environment (Chrome 131), we obtain results indicating how many successful lookups can be performed per second.

### Results Interpretation

From the latest benchmark results:
- The best performer is the `Conspicuous Obj lookup 2` with **359.60 executions per second**.
- Following closely, the `Conspicuous Obj lookup` achieved **354.22 executions per second**.
- The `Conspicuous Map lookup` and `Conspicuous Map lookup 2` lagged behind with **312.50** and **306.87 executions per second**, respectively.

This indicates that, at least in this specific benchmark and environment, the `Object` had superior performance compared to `Map` for string key lookups.

### Other Considerations and Alternatives

1. **WeakMap/WeakSet**: If you need to associate values with objects while avoiding memory leaks, consider using `WeakMap`, which allows for garbage collection of keys that are not referenced elsewhere.

2. **Nested Structures**: For complex data handling, one might consider using a combination of data structures (e.g., maps of maps) based on specific use cases.

3. **Performance Context**: The optimal choice between `Map` or `Object` can vary based on specific application requirements, including access patterns, memory considerations, and maintainability. As a rule of thumb, if order and diverse key types matter, `Map` is preferred. For straightforward string-keyed collections, `Object` is often adequate.

4. **JavaScript Engine Differences**: Performance can also vary based on the JavaScript engine being used (e.g., V8 in Chrome, SpiderMonkey in Firefox). It's crucial to test your case in the target environment.

Overall, understanding the performance characteristics of JavaScript `Map` and `Object` can guide developers in making informed decisions during the data handling process for their applications.

Related benchmarks:

Map vs Object (real-world) Performance with string keys (version: 2)

Lookup of map vs object (in a real-world test format)

Comparing performance of: Conspicuous Map lookup vs Conspicuous Obj lookup vs Conspicuous Map lookup 2 vs Conspicuous Obj lookup 2

Created: 3 months ago by: Registered User

Jump to the latest result

Conspicuous Map lookup

Conspicuous Obj lookup

Conspicuous Map lookup 2

Conspicuous Obj lookup 2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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