Benchmark: Map vs Object (real-world) Performance (lookup and set)

Script Preparation code:

var keyCount = 16384
var keys = []
var map = new Map()
var obj = {}
var emptyMap = new Map()
var emptyObj = {}


// 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] }
Conspicuous Map Set
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) emptyMap.set(key, seed) }
Conspicuous Obj Set
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) emptyObj[key] = seed }

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
Conspicuous Map Set
Conspicuous Obj Set

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and its various components, explaining what's being tested and discussing pros and cons of different approaches.

**Benchmark Overview**

The benchmark measures the performance of three data structures: `Map`, `Object`, and their empty counterparts (`emptyMap` and `emptyObj`). The test aims to find out which data structure performs better for a specific use case: lookup (getting a value by its key) and setting (inserting a new key-value pair).

**Script Preparation Code**

The script preparation code sets up the test environment:

1. It creates two maps (`map` and `emptyMap`) and an object (`obj`).
2. It generates 16,384 random keys and values using `Math.random()`.
3. The keys are stored in an array (`keys`).
4. A function `getConspicuousKey(seed)` is defined to select a key from the `keys` array based on the seed value.

**Html Preparation Code**

The HTML preparation code is empty, which means no additional setup or configuration is required for this benchmark.

**Individual Test Cases**

There are six test cases:

1. **Conspicuous Map lookup**: Retrieves a value from the map using the `map.get(key)` method.
2. **Conspicuous Obj lookup**: Retrieves a value from the object using the `obj[key]` syntax.
3. **Conspicuous Map lookup 2**: Similar to test case 1, but with a slight variation in how it uses the data structures (more on this later).
4. **Conspicuous Obj Set**: Inserts a new key-value pair into the object using the `obj[key] = value` syntax.
5. **Conspicuous Map Set**: Inserts a new key-value pair into the map using the `map.set(key, value)` method.
6. **Conspicuous Obj lookup 2**: Similar to test case 2, but with a slight variation in how it uses the data structures (more on this later).

**Key Differences between Test Cases**

The main difference between test cases 1 and 3 is that `map.get(key)` in test case 1 uses a direct lookup, whereas `map.get(key)` in test case 3 is not directly related to the key-value pair being set. This difference might be intended to test how the map handles different scenarios.

**Pros and Cons of Different Approaches**

Using `map.get(key)`, as in test cases 1 and 2:

* Pros:
	+ Faster lookup time due to caching.
	+ Better performance for frequent lookups.
* Cons:
	+ May lead to slower insertion times if the map is full.
	+ May not handle hash collisions efficiently.

Using `obj[key] = value`, as in test cases 4 and 5:

* Pros:
	+ Faster insertion times due to direct assignment.
	+ Better performance for sparse objects.
* Cons:
	+ Slower lookup times due to linear search.
	+ May lead to slower performance for large datasets.

**Empty Data Structures**

Using empty data structures (`emptyMap` and `emptyObj`) might be intended to test the overhead of creating new maps and objects. However, without additional context or benchmarking data, it's difficult to say which approach is more efficient in this case.

**Conclusion**

The benchmark appears to focus on comparing the performance of `Map`, `Object`, and their empty counterparts for lookup and insertion operations. The results will likely reveal that `Map` performs better for frequent lookups due to caching, while `Object` might be faster for sparse datasets or insertion-heavy workloads. However, without more context and benchmarking data, it's challenging to draw definitive conclusions about the best approach for specific use cases.

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/129.0.6668.69 Mobile/15E148 Safari/604.1

Browser/OS: Chrome Mobile iOS 129 on iOS 17.6

View result in a separate tab

Test name	Executions per second
Conspicuous Map lookup	209.4 Ops/sec
Conspicuous Obj lookup	142.7 Ops/sec
Conspicuous Map lookup 2	198.0 Ops/sec
Conspicuous Obj lookup 2	151.4 Ops/sec
Conspicuous Map Set	263.5 Ops/sec
Conspicuous Obj Set	175.0 Ops/sec

Related benchmarks:

Map vs Object (real-world) Performance (lookup and set) (version: 0)

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 vs Conspicuous Map Set vs Conspicuous Obj Set

Created: one year ago by: Guest

Jump to the latest result

Conspicuous Map lookup

Conspicuous Obj lookup

Conspicuous Map lookup 2

Conspicuous Obj lookup 2

Conspicuous Map Set

Conspicuous Obj Set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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