Benchmark: weakmap vs closure vs private symbols vs private symbol object

Script Preparation code:

function A() {
	var x = 0;
	return {
		incr() { x ++ },
		get() { return x },
	}
}
var closure = A();
closure.incr()

var wm = new WeakMap();
function B() {
	var x = {
		incr() { wm.set(x, (wm.get(x) || 0) + 1) },
		get() { return wm.get(x) },
	}
	return x
}
var weakmap = B();
weakmap.incr()


function C() {
	var me = Symbol('me');
	var x = {
		incr() { x[me]++ },
		get() { return x[me] },
		[me]: 0,
	}
	return x
}
var symbols = C();
symbols.incr()

var so = {};
function D() {
    var sym = Symbol('x')
    so[sym] = 0
	var x = {
		incr() { so[sym]++ },
		get() { return so[sym] },
	}
	return x
}
var pso = D();
pso.incr()

Tests:

closure get
closure.get()
weakmap get
weakmap.get()
closure incr
closure.incr()
weakmap incr
weakmap.incr()
symbol incr
symbols.incr()
pso incr
pso.incr()
pso get
pso.get()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
closure get
weakmap get
closure incr
weakmap incr
symbol incr
pso incr
pso get

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 121 on Windows

View result in a separate tab

closure get

24.1M/s

closure incr

23.7M/s

symbol incr

23.5M/s

pso get

12.0M/s

pso incr

12.0M/s

weakmap get

11.7M/s

weakmap incr

7.7M/s

View exact numbers

Test name	Executions per second
✓ closure get	24,103,636 Ops/sec
closure incr	23,721,064 Ops/sec
symbol incr	23,504,584 Ops/sec
pso get	12,031,869 Ops/sec
pso incr	11,982,350 Ops/sec
weakmap get	11,672,696 Ops/sec
weakmap incr	7,659,549 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 benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of four different approaches to implementing a simple incrementer and getter functions:

1. **Closure**: A closure is a function that has access to its own scope, including variables from the surrounding environment.
2. **WeakMap**: A WeakMap is a data structure in JavaScript that stores key-value pairs, where the key is an object and the value is any mutable value.
3. **Private Symbols**: Private symbols are a way to create private properties on objects using the `Symbol` function.
4. **Private Symbol Object**: This approach uses an object with a private symbol as its property.

**Test Cases**

The benchmark consists of six test cases:

1. `closure.get()`: Measures the time it takes to call the getter function of a closure.
2. `weakmap.get()`: Measures the time it takes to retrieve a value from a WeakMap using the key (an object).
3. `closure.incr()`: Measures the time it takes to increment the value in a closure.
4. `weakmap.incr()`: Measures the time it takes to increment the value in a WeakMap.
5. `symbols.incr()`: Measures the time it takes to increment a private symbol property on an object.
6. `pso.get()` and `pso.incr()`: These test cases measure the performance of using a private symbol object as a property.

**Library and Special JS Features**

* **WeakMap**: The WeakMap data structure is part of the JavaScript standard library.
* No other libraries are used in this benchmark.
* There are no special JavaScript features being tested (e.g., async/await, Promises, etc.).

**Pros and Cons of Each Approach**

1. **Closure**:
	* Pros: Simple to implement, easy to understand.
	* Cons: May have performance issues due to the creation of a new function scope on each call.
2. **WeakMap**:
	* Pros: Efficient use of memory, fast lookups.
	* Cons: Requires an object as the key, which may be slower than using a primitive value (e.g., a number).
3. **Private Symbols**:
	* Pros: New feature in JavaScript (ECMAScript 2020), allows for efficient private properties.
	* Cons: May not be supported by older browsers or environments.
4. **Private Symbol Object**:
	* Pros: Similar to private symbols, but uses an object as the property, which may be slower.
	* Cons: Less efficient than using private symbols directly.

**Other Alternatives**

Other approaches to implementing a simple incrementer and getter functions might include:

1. Using a `Map` instead of a WeakMap.
2. Implementing a custom data structure (e.g., a linked list) for the incrementer.
3. Using a different approach, such as using a binary counter.

However, these alternatives are not part of this benchmark, and the focus is on comparing the performance of the four approaches mentioned above.

weakmap vs closure vs private symbols vs private symbol object (version: 0) Benchmark.js

Comparing performance of: `closure get vs weakmap get vs closure incr vs weakmap incr vs symbol incr vs pso incr vs pso get`

Created: 2 years ago by: Guest

Go to the latest result

closure get

weakmap get

closure incr

weakmap incr

symbol incr

pso incr

pso get

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

weakmap vs closure vs private symbols vs private symbol object (version: 0) Benchmark.js

Comparing performance of: closure get vs weakmap get vs closure incr vs weakmap incr vs symbol incr vs pso incr vs pso get

Created: 2 years ago by: Guest

Go to the latest result

closure get

weakmap get

closure incr

weakmap incr

symbol incr

pso incr

pso get

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `closure get vs weakmap get vs closure incr vs weakmap incr vs symbol incr vs pso incr vs pso get`