Benchmark: Map vs Object (real-world) 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
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 Map lookup 2
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = map.get(key) }
Conspicuous Obj lookup 2
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = obj[key] }

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: 9 days ago)

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

Browser/OS: Chrome 149 on Windows

View result in a separate tab

Test name	Executions per second
Conspicuous Map lookup	394.7 Ops/sec
Conspicuous Obj lookup	219.9 Ops/sec
Conspicuous Map lookup 2	419.0 Ops/sec
Conspicuous Obj lookup 2	204.6 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark JSON and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The provided benchmark is designed to compare the performance of `Map` data structure vs `Object` data structure for lookup operations in JavaScript. The test is set up with a large number of keys (16,384) and random values assigned to each key.

**Script Preparation Code**

The script preparation code creates two objects: `map` and `obj`. Both are initialized with the same number of keys, but `map` uses a `Map` data structure, while `obj` uses an object literal. The code also defines a function `getConspicuousKey(seed)` that returns a seemingly random key index.

**Html Preparation Code**

There is no HTML preparation code provided for this benchmark, which means the test only runs in the JavaScript environment and does not involve any DOM-related operations.

**Individual Test Cases**

The benchmark consists of four test cases:

1. **Conspicuous Map lookup**: This test case iterates over the keys using `getConspicuousKey(seed)` and uses `map.get(key)` to look up values.
2. **Conspicuous Obj lookup**: Similar to the first test case, but uses `obj[key]` instead of `map.get(key)`.
3. **Conspicuous Map lookup 2**: Another iteration of the map lookup test case with a different seed value.
4. **Conspicuous Obj lookup 2**: Another iteration of the object lookup test case.

**Comparison**

The benchmark is designed to compare the performance of `Map` vs `Object` data structures for lookup operations. The comparison is done by executing each test case multiple times (the exact number is not specified) and measuring the execution time per second.

**Pros and Cons**

* **Map**: Pros:
	+ Efficient lookups using `map.get(key)`
	+ Can handle large amounts of data with minimal memory usage
	+ Can be used as a key-value store for caching or other purposes
* Cons:
	+ May not be suitable for all use cases (e.g., when the keys need to be iterated over)
* **Object**: Pros:
	+ Simple and widely supported in JavaScript engines
	+ Can be used as a simple data structure for small datasets
	+ Easy to understand and implement
* Cons:
	+ Lookup performance can be slower than using `Map`
	+ May not handle large amounts of data efficiently

**Library**

The benchmark uses the built-in `Map` and `Object` data structures in JavaScript. No external libraries are required.

**Special JS Feature or Syntax**

None mentioned in this explanation, but it's worth noting that `getConspicuousKey(seed)` is a clever trick to make the lookup keys seem random, which can affect the benchmark results.

**Alternatives**

Other alternatives for comparing the performance of data structures in JavaScript include:

* Using different data structure libraries like `Lodash` or `Ramda`
* Implementing custom data structures using bitwise operations or other techniques
* Using profiling tools to analyze the execution time of different data structures and algorithms

Related benchmarks:

Map vs Object (real-world) Performance (version: 4)

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: 5 years 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>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):