Benchmark: WeakMap vs "Symbol with WeakMap fallback"

Script Preparation code:

var c = Symbol === undefined
? (function() {
  var x = function() {
    this._x = new WeakMap();
  }
  x.prototype.get = function(x) { return this._x.get(x); };
  x.prototype.set = function(x,y) { this._x.set(x,y); };
  return x;
})()
: (function() {
  var x = function() {
    this._x = Symbol();
  }
  x.prototype.get = function(x) { return x[this._x]; };
  x.prototype.set = function(x,y) { x[this._x] = y; };
  return x;
})();

var to0 = {};
var to1 = {};
var wm = new WeakMap();
var fwm = new c();
wm.set(to1, 1);
fwm.set(to1, 1);

Tests:

WeakMap get
let r = wm.get(to1);
Symbol with WeakMap fallback get
let r = fwm.get(to1);
WeakMap set
wm.set(to0, 1);
Symbol with WeakMap fallback set
fwm.set(to0, 1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
WeakMap get
Symbol with WeakMap fallback get
WeakMap set
Symbol with WeakMap fallback set

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 147 on Windows

View result in a separate tab

Test name	Executions per second
WeakMap get	89051296.0 Ops/sec
Symbol with WeakMap fallback get	101222608.0 Ops/sec
WeakMap set	54469028.0 Ops/sec
Symbol with WeakMap fallback set	75904920.0 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's being tested.

**Benchmark Definition**

The benchmark is designed to compare two approaches for implementing WeakMaps in JavaScript: using `Symbol` and its fallback implementation, which uses a function to create a weak map-like object.

Here's a high-level overview of the test:

1. The script preparation code creates a `WeakMap` instance (`wm`) and a `Symbol with WeakMap fallback` instance (`fwm`). It also defines two objects, `to0` and `to1`, which are used as keys in the weak maps.
2. The benchmark defines four individual test cases:
	* Getting a value from `wm`
	* Getting a value from `fwm`
	* Setting a value in `wm`
	* Setting a value in `fwm`

**Options Compared**

The two options being compared are:

1. **`WeakMap`**: The native JavaScript implementation of a weak map.
2. **"Symbol with WeakMap fallback"**: A fallback implementation that uses a function to create a weak map-like object, relying on the presence of `Symbol` to provide a similar API.

**Pros and Cons**

Here are some pros and cons of each approach:

* **`WeakMap`**:
	+ Pros: Native implementation, well-tested, and optimized for performance.
	+ Cons: May not work in older browsers or environments that don't support `Symbol`.
* **"Symbol with WeakMap fallback"**:
	+ Pros: Works in all modern browsers and environments, provides a similar API to `WeakMap`.
	+ Cons: Has additional overhead due to the function creation, may be slower than native `WeakMap`.

**Library and Purpose**

There is no explicit library mentioned in the benchmark definition. However, the "Symbol with WeakMap fallback" implementation appears to rely on the `Symbol` primitive, which is a built-in JavaScript feature.

**Special JS Feature or Syntax**

The benchmark uses the `Symbol` primitive, which was introduced in ECMAScript 2015 (ES6). The `WeakMap` constructor also relies on this primitive. If your target browser or environment doesn't support `Symbol`, you may need to use a polyfill or a different implementation.

**Other Alternatives**

If you're looking for alternative implementations of WeakMaps, you can consider:

* `Map.prototype.set`: Some browsers and environments provide an extension of the `Map` constructor that allows setting values. However, this is not a standard implementation and may vary across platforms.
* Third-party libraries: There are several third-party libraries available that implement WeakMaps or similar data structures. These libraries often aim to provide better performance, compatibility, or features than the native implementations.

Keep in mind that these alternatives might have different trade-offs in terms of performance, compatibility, and feature set, so it's essential to evaluate them based on your specific use case and requirements.

Related benchmarks:

WeakMap vs "Symbol with WeakMap fallback" (version: 0)

Comparing performance of: WeakMap get vs Symbol with WeakMap fallback get vs WeakMap set vs Symbol with WeakMap fallback set

Created: 6 years ago by: Guest

Jump to the latest result

WeakMap get

Symbol with WeakMap fallback get

WeakMap set

Symbol with WeakMap fallback set

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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