Benchmark: Map vs WeakMap (real-world) Performance

Script Preparation code:

var keyCount = 16384
var keys = []
var map = new Map()
var weakmap = new WeakMap()


// 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 = {}
  keys.push(key)
  map.set(key,val)
  weakmap.set(key,val)
}

​x
 
var keyCount = 16384var keys = []var map = new Map()var weakmap = new WeakMap()​​// Hide lookup keys to prevent V8 cheating (AKA Optimizing)var getConspicuousKey = seed => keys[Math.floor(seed * keyCount)]​​// Setup out test objects w/ random valuesfor (let i=0; i<keyCount; i++) {  let val = Math.random()  let key = {}  keys.push(key)  map.set(key,val)  weakmap.set(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) }
for (let i=0; i<keyCount; i++) {
let seed = Math.random()
let key = getConspicuousKey(seed)
a = map.get(key)
}
Conspicuous WeakMap lookup
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = weakmap.get(key) }
for (let i=0; i<keyCount; i++) {
let seed = Math.random()
let key = getConspicuousKey(seed)
a = weakmap.get(key)
}
Conspicuous Map lookup 2
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = map.get(key) }
for (let i=0; i<keyCount; i++) {
let seed = Math.random()
let key = getConspicuousKey(seed)
a = map.get(key)
}
Conspicuous WeakMap lookup 2
for (let i=0; i<keyCount; i++) { let seed = Math.random() let key = getConspicuousKey(seed) a = weakmap.get(key) }
for (let i=0; i<keyCount; i++) {
let seed = Math.random()
let key = getConspicuousKey(seed)
a = weakmap.get(key)
}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Conspicuous Map lookup
Conspicuous WeakMap lookup
Conspicuous Map lookup 2
Conspicuous WeakMap lookup 2

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 months ago)

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

Browser/OS: Chrome 124 on Windows

View result in a separate tab

Test name	Executions per second
Conspicuous Map lookup	44.2 Ops/sec
Conspicuous WeakMap lookup	46.0 Ops/sec
Conspicuous Map lookup 2	44.6 Ops/sec
Conspicuous WeakMap lookup 2	46.4 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 4 months ago):

Measuring the performance of different data structures in JavaScript, such as Map and WeakMap, is crucial for optimizing applications.

Benchmark Definition

The benchmark tests the performance of looking up values in a Map versus a WeakMap. A Map is an object that stores key-value pairs, while a WeakMap is similar but allows keys to be garbage collected when they are no longer referenced.

Options Compared

Two options are compared:

Map lookup: This option uses the get() method of the Map interface to retrieve values based on their keys.
WeakMap lookup: This option uses the get() method of the WeakMap interface to retrieve values based on their keys.

Pros and Cons

Map:
- Pros: Can be used with any type of key, including non-primitive values like objects and arrays.
- Cons: Memory-intensive because it stores all keys in memory, even if they are no longer referenced. This can lead to performance issues if the map grows too large.
WeakMap:
- Pros: Can help prevent memory leaks by allowing keys to be garbage collected when they are no longer referenced.
- Cons: Requires a reference to the key object to retrieve its value, which can lead to slower lookup times.

Library

In this benchmark, neither Map nor WeakMap use any external libraries. They are built-in JavaScript data structures.

Special JS Feature/Syntax

This benchmark uses some advanced JavaScript features:

Template literals: Used in the getConspicuousKey() function to generate a random key.
Arrow functions: Used in the for...of loops to define small anonymous functions.
Computed property names: Used in the map and weakmap objects to create computed properties.

However, these features are not specific to JavaScript and are widely used in many programming languages.

Other Alternatives

If you're interested in comparing performance between different data structures in JavaScript, here are some alternatives:

Set vs WeakSet: Compare the performance of looking up values in a Set versus a WeakSet.
Array vs Int8Array: Compare the performance of accessing elements in an Array versus an Int8Array.
JSON.parse() vs `JSON.stringify()```: Compare the performance of parsing JSON strings using JSON.parse() versus stringifying JSON objects using JSON.stringify().

LLMs can make mistakes. Check important info.

Measuring the performance of different data structures in JavaScript, such as `Map` and `WeakMap`, is crucial for optimizing applications.

**Benchmark Definition**

The benchmark tests the performance of looking up values in a `Map` versus a `WeakMap`. A `Map` is an object that stores key-value pairs, while a `WeakMap` is similar but allows keys to be garbage collected when they are no longer referenced.

**Options Compared**

Two options are compared:

1. **`Map` lookup**: This option uses the `get()` method of the `Map` interface to retrieve values based on their keys.
2. **`WeakMap` lookup**: This option uses the `get()` method of the `WeakMap` interface to retrieve values based on their keys.

**Pros and Cons**

* **`Map`**:
	+ Pros: Can be used with any type of key, including non-primitive values like objects and arrays.
	+ Cons: Memory-intensive because it stores all keys in memory, even if they are no longer referenced. This can lead to performance issues if the map grows too large.
* **`WeakMap`**:
	+ Pros: Can help prevent memory leaks by allowing keys to be garbage collected when they are no longer referenced.
	+ Cons: Requires a reference to the key object to retrieve its value, which can lead to slower lookup times.

**Library**

In this benchmark, neither `Map` nor `WeakMap` use any external libraries. They are built-in JavaScript data structures.

**Special JS Feature/Syntax**

This benchmark uses some advanced JavaScript features:

* **Template literals**: Used in the `getConspicuousKey()` function to generate a random key.
* **Arrow functions**: Used in the `for...of` loops to define small anonymous functions.
* **Computed property names**: Used in the `map` and `weakmap` objects to create computed properties.

However, these features are not specific to JavaScript and are widely used in many programming languages.

**Other Alternatives**

If you're interested in comparing performance between different data structures in JavaScript, here are some alternatives:

* **`Set` vs `WeakSet`**: Compare the performance of looking up values in a `Set` versus a `WeakSet`.
* **`Array` vs `Int8Array`**: Compare the performance of accessing elements in an `Array` versus an `Int8Array`.
* **`JSON.parse()` vs `JSON.stringify()```**: Compare the performance of parsing JSON strings using `JSON.parse()` versus stringifying JSON objects using `JSON.stringify()`.

Related benchmarks:

Map vs WeakMap (real-world) Performance (version: 0)

Lookup of map vs object (in a real-world test format)

Comparing performance of: Conspicuous Map lookup vs Conspicuous WeakMap lookup vs Conspicuous Map lookup 2 vs Conspicuous WeakMap lookup 2

Created: 2 years ago by: Guest

Jump to the latest result

Conspicuous Map lookup

Conspicuous WeakMap lookup

Conspicuous Map lookup 2

Conspicuous WeakMap lookup 2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 4 months ago):