Benchmark: Map vs Object read performance for a 1000 key lookup - fixed

Script Preparation code:

var map = new Map();
var obj = {};

map.set('a', 5);
obj['a'] = 5;

var numberOfEntries = 100000

  

let i = 0;
var count = 1000;
var a;

Tests:

map-insert
for (let j = 0; j < numberOfEntries; j++){ const key = `a-${j}`; const value = j; map.set(key,value) }
obj insert
for (let j = 0; j < numberOfEntries; j++){ const key = `a-${j}`; const value = j; obj[key] = value; }
Map lookup
for (i = 0; i < count; i++) { const key = `a-${i}`; a = map.get(key); }
Obj lookup
for (i = 0; i < count; i++) { const key = `a-${i}`; a = obj[key]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
map-insert
obj insert
Map lookup
Obj lookup

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
map-insert	48.2 Ops/sec
obj insert	43.3 Ops/sec
Map lookup	3568.8 Ops/sec
Obj lookup	4098.1 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark provided is aimed at comparing the performance of reading and inserting data into two different data structures in JavaScript: `Map` and `Object`. Both of these are commonly used to store key-value pairs, but they have distinct characteristics that can affect their performance depending on usage patterns.

### Comparisons in the Benchmark

1. **Insertion Performance:**
   - **Test Name: `map-insert`**
     - **Code:** The code uses a loop to insert 100,000 key-value pairs into a `Map`. For each iteration, a key is constructed in the format `a-{j}` and is assigned a value of `j`.
   - **Test Name: `obj insert`**
     - **Code:** Similarly, this test inserts 100,000 key-value pairs into a plain JavaScript `Object` using a similar key format.

2. **Lookup Performance:**
   - **Test Name: `Map lookup`**
     - **Code:** In this case, the benchmark retrieves values for 1,000 keys from the `Map` created earlier. The key format is retained.
   - **Test Name: `Obj lookup`**
     - **Code:** This test retrieves values from the `Object` using the same key format as with `Map`.

### Results Analysis

From the latest benchmark results:

- **Lookup performance** is significantly better for `Object` compared to `Map`. The `Object` had an executions per second rate of approximately 7249, while the `Map` yielded about 5977.
- **Insertion performance** is slightly faster for `Map` (around 77 ops/s) than for `Object` (approximately 73 ops/s), although both are generally much slower than the lookup operations.

### Pros and Cons

**Map:**
- **Pros:**
  - Maintains the insertion order of keys.
  - Can use objects or functions as keys (which is not possible with `Object`).
  - More built-in methods (like `size`, `has`, etc.) for easier manipulation.

- **Cons:**
  - Typically exhibits slower lookup performance in certain situations, especially when a high number of lookups is involved.
  - Slightly more overhead in terms of memory and performance for simple key-value pair use cases compared to `Object`.

**Object:**
- **Pros:**
  - Generally faster for lookups in many scenarios due to native optimizations.
  - Lightweight solution for non-complex key-value storage.

- **Cons:**
  - Does not guarantee key order (though modern JavaScript engines have improved this).
  - Only supports string and Symbol types as keys.
  - Fewer built-in methods specifically for managing collections compared to `Map`.

### Other Considerations and Alternatives

While this benchmark specifically compares `Map` and `Object`, other alternatives for storing key-value pairs in JavaScript include:

- **WeakMap:** Similar to `Map`, but can only hold objects as keys and does not prevent garbage collection of keys. It's mainly useful in scenarios where you want temporary associations between objects without preventing their garbage collection.
- **Array:** For scenarios involving indexed storage rather than key-value lookups, arrays might be beneficial, especially when using the index for accessing data. 
- **Set:** Although it doesn't hold key-value pairs, it's useful for storing unique values and can be relevant when you care about uniqueness rather than association.

### Conclusion

This benchmark serves as an illuminating comparison between `Map` and `Object`, both of which provide different performance characteristics for insertion and lookup. The choice between them hinges on the specific use case being addressed, particularly concerning the types of data being handled and the performance needs of the application. Understanding these differences will help software engineers select the appropriate data structure in their JavaScript applications.

Related benchmarks:

Map vs Object read performance for a 1000 key lookup - fixed (version: 0)

Lookup of map vs object

Comparing performance of: map-insert vs obj insert vs Map lookup vs Obj lookup

Created: 2 months ago by: Guest

Jump to the latest result

map-insert

obj insert

Map lookup

Obj lookup

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