Benchmark: Map vs Object (Lookup then delete keys fix) Performance

Script Preparation code:

var keyCount = 16384
var keys = []
var map = new Map()
var obj = {}


// 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 & delete
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = map.get(key) map.delete(key) }
Conspicuous Obj lookup & delete
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = obj[key] delete obj[key] }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Conspicuous Map lookup & delete
Conspicuous Obj lookup & delete

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 Edg/133.0.0.0

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
Conspicuous Map lookup & delete	237.5 Ops/sec
Conspicuous Obj lookup & delete	94.2 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark is designed to compare the performance of two data structures in JavaScript: `Map` and plain `Object`, specifically focusing on their lookup and deletion operations.

### Benchmark Overview

1. **Benchmark Purpose**: This benchmark evaluates how efficiently a `Map` performs lookups and deletions compared to an `Object` when both are populated with the same set of keys and values. The test emphasizes a situation where keys are accessed in a conspicuous manner to prevent JavaScript's V8 engine from optimizing the lookups.

2. **Key Definitions**:
   - **Map**: A built-in JavaScript object that holds key-value pairs and maintains the insertion order of the keys. It provides methods like `.get()`, `.set()`, and `.delete()`, which facilitate interacting with the stored data.
   - **Object**: A traditional JavaScript object used for storing key-value pairs but does not maintain order and requires the use of bracket notation (`obj[key]`) or the `delete` operator for accessing or modifying its properties.

### Test Cases

1. **Conspicuous Map lookup & delete**:
   - **Code**: For each key in the `Map`, the benchmark retrieves the value using the `map.get(key)` method and then deletes the key with `map.delete(key)`.
   - **Performance Factor**: The performance is measured in terms of executions per second, putting emphasis on the efficiency of the retrieval and removal processes.

2. **Conspicuous Obj lookup & delete**:
   - **Code**: Similarly, for each key in the `Object`, the benchmark retrieves the value using `obj[key]` and deletes the key using `delete obj[key]`.
   - **Performance Factor**: This section evaluates how well the traditional object handles similar operations.

### Performance Results

The benchmark results indicate:
- **Map**: 1344.72 executions per second
- **Object**: 116.61 executions per second

These results suggest that the `Map` performs significantly better than the `Object` for the specific operations tested.

### Pros and Cons of Using Map vs Object

- **Pros of Map**:
  - **Performance**: Generally faster for dynamic key-value storage and access (as seen in the results).
  - **Order Maintenance**: Maps maintain the order of insertion, which can be useful in certain applications.
  - **Different Key Types**: Supports various types of keys (not restricted to strings or symbols).

- **Cons of Map**:
  - **Memory Overhead**: Slightly more memory-consuming than Objects due to their more complex structure.
  - **Bigger API Surface**: More methods and complexity might lead to confusion for new developers.

- **Pros of Object**:
  - **Simplicity**: Easier to understand for simple use cases, with minimal overhead.
  - **Familiarity**: Long-established within JavaScript, which might make them the preferred choice in legacy code.

- **Cons of Object**:
  - **Performance**: Slower for frequent dynamic key access and modification.
  - **Key Constraints**: Limited to strings and symbols as keys; using other types (like objects) will convert them to strings.

### Other Considerations

- **Browser Variability**: Performance results can vary based on the JavaScript engine and the specific browser being used, which may result in inconsistencies.
- **Use Cases**: For scenarios where dynamic key manipulation is necessary or order matters, using `Map` is generally advisable. For static lookups, simple Object usages still fit well.

### Alternatives

Depending on the specific requirements of an application, alternatives to `Map` and `Object` include:

- **WeakMap**: Similar to `Map` but allows for garbage collection of its keys, which can be beneficial for memory management.
- **Set**: Stores unique values of any type, similar to a mathematical set; useful when the relationship of items is more important than their key-value pairs.
- **Custom Data Structures**: Depending on the application, developers might implement various data structures like hash tables or trees for more controlled performance and functionality.

Ultimately, deciding whether to use `Map` or an `Object` should depend on the specific needs of the application regarding performance, memory, and functionality.

Related benchmarks:

Map vs Object (Lookup then delete keys fix) Performance (version: 1)

Lookup of map vs object then delete keys w/o checking

Comparing performance of: Conspicuous Map lookup & delete vs Conspicuous Obj lookup & delete

Created: 2 months ago by: Guest

Jump to the latest result

Conspicuous Map lookup & delete

Conspicuous Obj lookup & delete

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