Benchmark: WeakMap vs Symbol Property

Script Preparation code:

var to0 = {};
var to1 = {};
var wm = new WeakMap();
var sy = Symbol();
wm.set(to1, 1);
to1[sy] = 1;

Tests:

WeakMap set
wm.set(to0, 1);
Symbol Property set
to0[sy] = 1;
WeakMap get
let r = wm.get(to1);
Symbol Property get
let r = to1[sy];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
WeakMap set
Symbol Property set
WeakMap get
Symbol Property get

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 135 on Windows

View result in a separate tab

Test name	Executions per second
WeakMap set	130788792.0 Ops/sec
Symbol Property set	199113888.0 Ops/sec
WeakMap get	130222752.0 Ops/sec
Symbol Property get	208484848.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested.

**Benchmark Definition**

The benchmark is comparing two approaches: using a `WeakMap` data structure and using a symbol property (represented by the `Symbol` variable `sy`) to store and retrieve values.

**Script Preparation Code**

The script creates two empty objects, `to0` and `to1`, and initializes a new `WeakMap` instance, `wm`. It also declares a symbol variable, `sy`.

```javascript
var to0 = {};
var to1 = {};
var wm = new WeakMap();
var sy = Symbol();
```

The script then sets up two test cases:

1. `wm.set(to1, 1);`: Sets a value in the `WeakMap`.
2. `to1[sy] = 1;`: Stores a value using the symbol property.
3. `let r = wm.get(to1);`: Retrieves a value from the `WeakMap` using the key `to1`.
4. `let r = to1[sy];`: Retrieves a value using the symbol property.

**Individual Test Cases**

Each test case runs a single benchmark definition, comparing the performance of the two approaches ( `WeakMap` and symbol property).

**Comparison of Approaches**

The pros and cons of these approaches are:

* **WeakMap**: Advantages:
	+ Efficient memory management: WeakMaps automatically remove entries when the corresponding object is garbage collected.
	+ Fast lookups: WeakMaps use a hash table for fast lookups.
* Disadvantages:
	+ Limited key types: Only primitive values (e.g., numbers, strings) and objects with a `[[Prototype]]` property can be used as keys.
	+ No direct support for symbol properties as keys.
* **Symbol Property**: Advantages:
	+ Flexible key types: Symbols can be used as keys, making them useful when working with objects that have unique properties.
	+ Native support in most browsers
* Disadvantages:
	+ Inefficient memory management: When an object holding a symbol property is garbage collected, the symbol property itself is not removed from other objects referencing it.
	+ Potential performance impact due to unnecessary copies or allocations.

**Library and Special JS Features**

The benchmark uses `WeakMap`, which is a built-in JavaScript data structure. No special libraries or modules are required.

No special JS features or syntax are being tested in this benchmark.

**Other Alternatives**

Alternative approaches to WeakMaps and symbol properties include:

* Using the `Object` prototype's `set` method with a custom object as the key (not recommended due to performance issues).
* Implementing a simple hash table or trie data structure.
* Using a library like Lodash, which provides a `WeakMap` implementation.

Keep in mind that WeakMaps are a built-in JavaScript feature and are likely the most efficient and convenient solution for this use case.

Related benchmarks:

WeakMap vs Symbol Property (version: 0)

Comparing performance of: WeakMap set vs Symbol Property set vs WeakMap get vs Symbol Property get

Created: 5 years ago by: Guest

Jump to the latest result

WeakMap set

Symbol Property set

WeakMap get

Symbol Property get

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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