Benchmark: Map vs Object (real-world) Performance (non-numeric key)

Script Preparation code:

var keyCount = 16384
var keys = []
var map = new Map()
var obj = {}
var accessKeys = [];


// 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('x' + key)
  map.set(key,val)
  obj[key] = val
}

var conspicuousKeys = keys.map(() => getConspicuousKey(Math.random()))
var a = null

Tests:

Conspicuous Map lookup
for (let i=0; i<keyCount; i++) { a = map.get(conspicuousKeys[i]) }
Conspicuous Obj lookup
for (let i=0; i<keyCount; i++) { a = obj[conspicuousKeys[i]] }
Conspicuous Map set
var mapX = new Map(); for (let i=0; i<keyCount; i++) { mapX.set(conspicuousKeys[i], 0) }
Conspicuous Obj set
var objX = {}; for (let i=0; i<keyCount; i++) { objX[conspicuousKeys[i]] = 0 }
Conspicuous Map get miss
for (let i=0; i<keyCount; i++) { a = map.get('not-existed') }
Conspicuous Obj get miss
for (let i=0; i<keyCount; i++) { a = obj['not-existed'] }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Conspicuous Map lookup
Conspicuous Obj lookup
Conspicuous Map set
Conspicuous Obj set
Conspicuous Map get miss
Conspicuous Obj get miss

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 127 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Conspicuous Map lookup	390.7 Ops/sec
Conspicuous Obj lookup	413.4 Ops/sec
Conspicuous Map set	622.1 Ops/sec
Conspicuous Obj set	713.1 Ops/sec
Conspicuous Map get miss	626.4 Ops/sec
Conspicuous Obj get miss	683.0 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 benchmark definition and individual test cases to understand what's being tested.

**Benchmark Definition:**

The benchmark is designed to compare the performance of two data structures: Maps (JavaScript objects with key-value pairs) and Objects (regular JavaScript objects). The test is focused on a "real-world" scenario where lookup operations are performed using non-numeric keys. This means that instead of using numeric indices, the keys used for lookup are strings.

**Script Preparation Code:**

The script preparation code sets up two test objects, `map` and `obj`, and generates random key-value pairs. The `keys` array is used to create a "conspicuous" set of keys by multiplying each element by a seed value, which helps hide the true nature of the keys from the JavaScript engine (known as "V8 cheating" or optimizing).

**Html Preparation Code:**

There is no HTML preparation code provided.

**Individual Test Cases:**

There are six test cases:

1. **Conspicuous Map lookup**: This test case performs a lookup operation on the `map` object using the generated conspicuous keys.
2. **Conspicuous Obj lookup**: This test case performs a lookup operation on the `obj` object using the generated conspicuous keys.
3. **Conspicuous Map set**: This test case sets values in the `map` object using the generated conspicuous keys.
4. **Conspicuous Obj set**: This test case sets values in the `obj` object using the generated conspicuous keys.
5. **Conspicuous Map get miss**: This test case attempts to perform a lookup operation on the `map` object using a key that doesn't exist.
6. **Conspicuous Obj get miss**: This test case attempts to perform a lookup operation on the `obj` object using a key that doesn't exist.

**Library Used:**

None, as this is a custom benchmarking script.

**Special JavaScript Features/Syntax:**

The benchmark uses a few advanced features and syntax:

* **Conspicuous keys**: The generated keys are used to hide the true nature of the keys from the JavaScript engine.
* **Map and Object literals**: The `map` and `obj` objects are created using literal notation, which is a concise way to create objects in JavaScript.
* **Looping constructs**: The benchmark uses `for` loops to iterate over the generated key-value pairs.

**Pros and Cons of Different Approaches:**

Using Maps vs Objects for lookup operations has different performance characteristics:

* **Maps**:
	+ Pros: Fast lookups, especially for large datasets. Maps have an average time complexity of O(1) for lookups.
	+ Cons: May incur additional overhead due to the use of hash tables and collisions.
* **Objects**:
	+ Pros: Faster access times than arrays or other data structures. Objects are more efficient when accessing data by key.
	+ Cons: Slower lookups compared to Maps, especially for large datasets.

In this benchmark, using Maps seems to outperform Objects for lookup operations, but the performance differences are relatively small. The use of conspicuous keys and loops helps hide these performance variations from the JavaScript engine.

**Conclusion:**

This benchmarking script tests the performance of Map and Object data structures for lookup operations using non-numeric keys. The results suggest that Maps perform better than Objects for this specific scenario, but the performance difference is relatively small.

Related benchmarks:

Map vs Object (real-world) Performance (non-numeric key) (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 set vs Conspicuous Obj set vs Conspicuous Map get miss vs Conspicuous Obj get miss

Created: one year ago by: Registered User

Jump to the latest result

Conspicuous Map lookup

Conspicuous Obj lookup

Conspicuous Map set

Conspicuous Obj set

Conspicuous Map get miss

Conspicuous Obj get miss

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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