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

Script Preparation code:

var keyCount = 16384
var keys = []
var map = new Map()
var obj = Object.create(null)
delete obj.x


// 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().toString()
  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

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition**

The provided JSON represents a benchmark definition for comparing the performance of looking up values in a `Map` object versus an object literal (`Object`) in a real-world scenario. The script preparation code sets up two objects, `map` and `obj`, with 16,384 keys each, populated with random values. The test cases then perform lookups on these objects using the `get()` method.

**Options Compared**

Two options are compared:

1. **Conspicuous Map lookup**: This option uses a `Map` object to store key-value pairs and performs a lookup using the `get()` method.
2. **Conspicuous Object lookup**: This option uses an object literal (`Object`) to store key-value pairs and performs a lookup using the bracket notation (`obj[key]`).

**Pros and Cons**

**Conspicuous Map lookup:**

Pros:

* `Map` objects are designed for fast lookups, making them suitable for this type of benchmark.
* The `get()` method is optimized for performance.

Cons:

* May be slower due to the overhead of creating a `Map` object.
* Can be affected by the number of keys in the map.

**Conspicuous Object lookup:**

Pros:

* Has no overhead of creating an object, making it potentially faster.
* Can be more cache-friendly due to the use of bracket notation.

Cons:

* Bracket notation can be slower than the `get()` method.
* May not be as performant as a `Map` object for large datasets.

**Other Considerations**

* The use of `Math.random()` to generate random values and keys ensures that the test cases are representative of real-world data.
* The `delete obj.x` statement is used to remove the `x` property from the object, making it difficult for V8 (the JavaScript engine in Chrome) to optimize away.
* The `getConspicuousKey` function generates a random key using `Math.random().toString()`, which helps hide the true nature of the lookup.

**Library**

The `Map` object is a built-in JavaScript library, and its purpose is to provide a data structure for storing key-value pairs in an efficient manner. The `Object.create(null)` method is used to create an empty object literal, which is then populated with values using bracket notation (`obj[key]`).

**Special JS Feature or Syntax**

The benchmark does not use any special JavaScript features or syntax beyond what's required for the task at hand.

**Alternatives**

Other alternatives for comparing performance could include:

* Using a `Set` data structure instead of a `Map`
* Comparing the performance of using a `Map` object versus an object literal with a fixed number of keys
* Adding additional complexity to the test cases, such as sorting or filtering the data
* Using a different JavaScript engine or interpreter for benchmarking

Keep in mind that the choice of alternative will depend on the specific goals and requirements of the benchmark.

Latest run results:

Run details: (Test run date: 14 days ago)

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

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Conspicuous Map lookup	142.8 Ops/sec
Conspicuous Obj lookup	158.1 Ops/sec
Conspicuous Map lookup 2	145.2 Ops/sec
Conspicuous Obj lookup 2	159.8 Ops/sec

Related benchmarks:

Map vs Object (real-world) Performance (better) (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

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

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):