Benchmark: Map vs Object (real-world) vs PureObject Performance

Script Preparation code:

var keyCount = 16384
var keys = []
var map = new Map()
var obj = {}
var pureObj = Object.create(null)


// 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
  pureObj[key] = val
}

Tests:

Conspicuous Map lookup
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = map.get(key) }
Conspicuous Obj lookup
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = obj[key] }
Conspicuous PureObj lookup
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = pureObj[key] }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Conspicuous Map lookup	467.2 Ops/sec
Conspicuous Obj lookup	329.0 Ops/sec
Conspicuous PureObj lookup	327.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark titled "Map vs Object (real-world) vs PureObject Performance" is designed to evaluate the performance of three different JavaScript data structures—`Map`, an ordinary JavaScript `Object`, and a `PureObject` (which is essentially an object created with `Object.create(null)`). The main focus is on the speed of key lookups in these data structures using the same dataset.

### Data Structures Compared

1. **Map**:
   - **Description**: `Map` is a built-in JavaScript object that holds key-value pairs. The keys can be of any data type, and its main feature is that insertion, deletion, and access have consistent time complexity.
   - **Pros**: 
     - Maintains the order of insertion.
     - Supports any data type as a key.
     - More efficient for frequent additions and removals.
   - **Cons**: 
     - Slightly higher memory overhead compared to Object.
     - Generally slower for basic property accesses compared to plain Objects in certain cases.

2. **Object**:
   - **Description**: An ordinary JavaScript object, which is a collection of key-value pairs. Keys are primarily strings (or symbols), and it comes with built-in prototype properties/methods.
   - **Pros**: 
     - Very lightweight and performant for accessing properties with string keys.
     - Well-suited for JSON-like data structures.
   - **Cons**: 
     - Key types are restricted to strings (and symbols), meaning non-string keys need to be coerced to strings.
     - Inherits properties from its prototype, which could potentially lead to unintended behavior if keys conflict.

3. **PureObject**:
   - **Description**: This is a more simple object that does not have any prototype, created using `Object.create(null)`. This means it does not inherit from `Object.prototype`, hence it avoids unintended key conflicts.
   - **Pros**: 
     - Completely clean and less prone to "unexpected" behavior due to inherited properties.
     - Potentially slightly faster than a regular object for property accesses, due to the lack of prototype lookups.
   - **Cons**: 
     - No prototype methods available (like `.hasOwnProperty()`), which might require additional checks when managing keys.

### Test Cases in Benchmark

The benchmark consists of three test cases that measure the performance of lookups for each of the aforementioned data structures:

1. **Conspicuous Map lookup**: Looks up a randomly selected key from a `Map`.
2. **Conspicuous Obj lookup**: Looks up a randomly selected key from a regular `Object`.
3. **Conspicuous PureObj lookup**: Looks up a randomly selected key from a `PureObject`.

Each test case runs multiple iterations to obtain a measure of how many lookups can be performed per second, resulting in a performance score expressed as "ExecutionsPerSecond."

### Benchmark Results

Here are the results from the latest benchmark:

- **Map lookup**: Approximately 375.59 executions per second.
- **PureObject lookup**: Approximately 257.53 executions per second.
- **Object lookup**: Approximately 252.81 executions per second.

### Other Considerations & Alternatives

- **Choose Based on Use Case**: The choice between these data structures largely depends on the specific use case. If the need for complex keys or maintaining order is present, `Map` is preferable. For simple keys and quick access, traditional `Objects` might suffice.
- **JSON vs. HTML Data**: If interfacing with JSON, regular `Object` is generally the norm. However, performance-sensitive applications may benefit from `Map` for larger collections with dynamic key-value pairs.
- **Other Alternatives**: Aside from these three, other data structures like `Set` (for unique values) or even third-party libraries like Immutable.js for more complex data handling might be considered, depending on the specific program requirements.

In conclusion, understanding these differences in performance characteristics can aid software engineers in selecting the most appropriate data structure for their specific needs, balancing factor implications like performance, complexity, and key types.

Related benchmarks:

Map vs Object (real-world) vs PureObject Performance (version: 1)

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

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

Created: 3 months ago by: Guest

Jump to the latest result

Conspicuous Map lookup

Conspicuous Obj lookup

Conspicuous PureObj lookup

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