Benchmark: WeakMap vs Symbol 3

Script Preparation code:

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

Tests:

WeakMap set
wm.set(to0, 1);
Symbol Property set
to0[sy] = 1;
WeakMap get
r = wm.get(to1);
Symbol Property get
r = to1[sy];
Symbol Property get (from own descriptor)
r = Object.getOwnPropertyDescriptor(to1, sy).value;
Symbol Property get (if hasOwn)
r = Object.hasOwn(to1, sy) ? to1[sy] : undefined;

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
Symbol Property get (from own descriptor)
Symbol Property get (if hasOwn)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring performance differences between various JavaScript approaches can be complex, but I'll break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of three approaches for accessing Symbol properties:

1. **Direct Property Access**: Using the `[]` syntax to access a symbol property on an object.
2. **WeakMap Get**: Using a WeakMap to store a reference to an object, and then retrieving it using the `get()` method.
3. **Symbol Property Get (from own descriptor)**: Using the `Object.getOwnPropertyDescriptor()` function to retrieve the value of a symbol property from its owning object's descriptor.
4. **Symbol Property Get (if hasOwn)**: Using the `Object.hasOwn()` function to check if an object has a symbol property, and then retrieving it using the `[]` syntax.

**Benchmark Script**

The script preparation code sets up two objects (`to0` and `to1`) and creates a WeakMap (`wm`) with a symbol key (`sy`). The script also defines some test functions that will be used to benchmark each approach.

**Benchmark Test Cases**

The test cases are designed to execute the following scenarios:

1. **WeakMap set**: Create a new entry in the WeakMap using `wm.set(to0, 1)`.
2. **Symbol Property set**: Set the value of the symbol property on an object (`to1[sy] = 1`).
3. **WeakMap get**: Retrieve the value from the WeakMap using `r = wm.get(to1)`.
4. **Symbol Property get**: Retrieve the value of the symbol property on an object (`to1[sy]`) directly.
5. **Symbol Property get (from own descriptor)**: Use `Object.getOwnPropertyDescriptor()` to retrieve the value of the symbol property from its owning object's descriptor.
6. **Symbol Property get (if hasOwn)**: Check if the object has a symbol property using `Object.hasOwn()`, and then retrieve it using the `[]` syntax.

**Performance Comparison**

The benchmark measures the performance of each approach by executing each test case repeatedly, and reports the average number of executions per second for each browser version.

**Pros and Cons of Each Approach**

1. **Direct Property Access**:
	* Pros: Fast and straightforward.
	* Cons: May lead to unexpected behavior if not used carefully (e.g., using `Symbol()` with a string value).
2. **WeakMap Get**:
	* Pros: Can be useful for caching or storing references to objects without creating strong references.
	* Cons: Requires careful management of the WeakMap to avoid memory leaks.
3. **Symbol Property Get (from own descriptor)**:
	* Pros: Allows access to symbol properties using their owning object's descriptor.
	* Cons: May require additional setup and bookkeeping.
4. **Symbol Property Get (if hasOwn)**:
	* Pros: Simplifies the process of checking if an object has a symbol property before trying to access it.
	* Cons: May lead to slower performance due to the added overhead of `Object.hasOwn()`.

**Other Considerations**

* When using WeakMaps, be aware that they do not prevent objects from being garbage collected, as long as there are no strong references to those objects.
* When accessing symbol properties, be mindful of potential conflicts between symbol names and other property names.
* Consider the use case and requirements when choosing an approach. For example, if you need to cache or store references to objects without creating strong references, a WeakMap may be suitable.

**Alternatives**

Other alternatives for accessing symbol properties or caching/retrieving data include:

* Using `Object.keys()` or `Object.getOwnPropertyNames()` to iterate over own property names.
* Utilizing libraries like Lodash or Ramda for more functional programming approaches.
* Implementing custom caching mechanisms using techniques like memoization or dependency injection.

Latest run results:

Run details: (Test run date: one month 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 Edg/129.0.0.0

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
WeakMap set	14126756.0 Ops/sec
Symbol Property set	14978403.0 Ops/sec
WeakMap get	7216884.5 Ops/sec
Symbol Property get	7425304.5 Ops/sec
Symbol Property get (from own descriptor)	4879848.0 Ops/sec
Symbol Property get (if hasOwn)	3861038.2 Ops/sec

Related benchmarks:

WeakMap vs Symbol 3 (version: 0)

Comparing performance of: WeakMap set vs Symbol Property set vs WeakMap get vs Symbol Property get vs Symbol Property get (from own descriptor) vs Symbol Property get (if hasOwn)

Created: one month ago by: Guest

Jump to the latest result

WeakMap set

Symbol Property set

WeakMap get

Symbol Property get

Symbol Property get (from own descriptor)

Symbol Property get (if hasOwn)

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):