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

Test name	Executions per second
closure get	24103636.0 Ops/sec
weakmap get	11672696.0 Ops/sec
closure incr	23721064.0 Ops/sec
weakmap incr	7659549.0 Ops/sec
symbol incr	23504584.0 Ops/sec
pso incr	11982350.0 Ops/sec
pso get	12031869.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 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.

Related benchmarks:

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

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

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