Benchmark: WeakMap vs Symbol

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;

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)

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/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	14262492.0 Ops/sec
Symbol Property set	14462870.0 Ops/sec
WeakMap get	7349803.5 Ops/sec
Symbol Property get	7678899.0 Ops/sec
Symbol Property get (from own descriptor)	5070251.5 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 provided benchmark and explain what is being tested, the options compared, their pros and cons, and other considerations.

**Benchmark Context**

The benchmark compares the performance of setting and getting symbols in JavaScript using two approaches: `WeakMap` with a symbol key and direct property access with a symbol. This comparison aims to evaluate which approach is faster for small-scale object lookup tasks.

**Options Compared**

1. **WeakMap set**: Using `WeakMap` to store an object with a symbol as its key.
2. **Symbol Property set**: Directly setting a property on an object using a symbol as its name.
3. **WeakMap get**: Retrieving the value associated with a symbol key from a `WeakMap`.
4. **Symbol Property get**: Directly accessing a property with a symbol as its name.
5. **Symbol Property get (from own descriptor)**: Using `Object.getOwnPropertyDescriptor` to retrieve the value of a property with a symbol as its name, using its own descriptor.

**Pros and Cons**

1. **WeakMap set**:
	* Pros:
		+ Weak references are automatically cleaned up when the object is no longer referenced.
		+ No need to manually delete symbols from `Object.prototype`.
	* Cons:
		+ Creates a new symbol for each lookup, which can be slow for large sets.
2. **Symbol Property set**:
	* Pros:
		+ Symbols are hashable and unique.
		+ Can be used with other data structures like arrays or maps.
	* Cons:
		+ Performance can degrade if symbols are not properly optimized (e.g., using `Object.defineProperty`).
3. **WeakMap get**:
	* Pros:
		+ Fast lookups since WeakMaps use a hash table.
		+ No performance penalty for getting the value associated with a symbol key.
4. **Symbol Property get**:
	* Pros:
		+ Uses existing property access mechanisms, which are optimized.
		+ Faster lookups compared to creating a new symbol for each lookup.
5. **Symbol Property get (from own descriptor)**:
	* Pros:
		+ Can be used when symbols are not supported or needed for other reasons.
		+ Fast lookups since it uses existing property access mechanisms.

**Other Considerations**

* The `WeakMap` approach is likely to perform better due to its use of a hash table, which allows for fast lookups.
* Direct property access using symbols can be faster than creating and looking up new symbols for each lookup.
* Using `Object.getOwnPropertyDescriptor` for symbol property retrieval may incur additional overhead compared to direct property access.

**Library/Functionality**

* No specific libraries are used in this benchmark. It relies solely on built-in JavaScript features like `WeakMap`, `Symbol`, and `Object.prototype`.

**Special JS Features/Syntax**

* Symbols are the new, unique identifiers introduced in ECMAScript 2015.
* WeakMaps were introduced in ECMAScript 2009.

In summary, this benchmark compares the performance of different approaches to setting and getting symbols in JavaScript. The results will help determine which approach is faster for small-scale object lookup tasks, considering factors like symbol creation overhead, hash table lookups, and property access mechanisms.

Related benchmarks:

WeakMap vs Symbol (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)

Created: one year ago by: Guest

Jump to the latest result

WeakMap set

Symbol Property set

WeakMap get

Symbol Property get

Symbol Property get (from own descriptor)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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