Benchmark: weakmap vs closure vs private symbols

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

Tests:

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

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

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares three approaches to implement a simple counter:

1. **Closure**: A closure is an object that has access to its own scope, even when the outer function has returned. In this case, we create a closure `A` that returns an object with two methods: `incr()` and `get()`.
2. **WeakMap**: A WeakMap is a data structure that stores key-value pairs where the keys are objects, not primitive values like numbers or strings. The garbage collector can remove entries if there are no more references to them. In this case, we create a function `B` that returns an object with two methods: `incr()` and `get()`, which uses a WeakMap to store the counter.
3. **Private Symbols**: Private symbols (also known as "symbols") are a feature introduced in ECMAScript 2015 (ES6) that allows creating private properties on objects. In this case, we create an object `C` with a private symbol `me`, which is used to implement a simple counter.

**Options Compared**

The benchmark compares the performance of these three approaches:

* Closure (`A`)
* WeakMap (`B`)
* Private Symbols (`C`)

Each option has its pros and cons:

* **Closure**: Pros - Simple to implement, widely supported. Cons - May lead to memory leaks if not managed properly.
* **WeakMap**: Pros - Efficient use of memory, garbage collection handles cleanup. Cons - May have performance overhead due to the WeakMap implementation.
* **Private Symbols**: Pros - Encapsulation, readability, and maintainability benefits. Cons - Limited support across older browsers (only ES6+), may require additional setup.

**Library Used**

None of the options rely on a specific library or framework. The code is self-contained and focuses on demonstrating the performance comparison between these three approaches.

**Special JS Features/ Syntax**

Private symbols (`C`) are used to create a private property `me` on the object, which allows for encapsulation and improves readability. This feature requires ES6+ support.

**Benchmark Preparation Code**

The script preparation code defines the functions `A`, `B`, and `C`, which implement the counter logic using the respective approaches. The html preparation code is empty.

**Alternatives**

Other alternatives for implementing a simple counter could be:

* Using a primitive number (e.g., an integer) instead of an object with methods.
* Utilizing other data structures, such as arrays or sets, to store the counter value.
* Implementing a custom data structure or algorithm to optimize performance.

However, these alternatives are not part of the provided benchmark and would require additional consideration for their own pros and cons.

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36

Browser/OS: Chrome 129 on Linux

View result in a separate tab

Test name	Executions per second
closure get	21073060.0 Ops/sec
weakmap get	10293698.0 Ops/sec
closure incr	20810210.0 Ops/sec
weakmap incr	6524745.0 Ops/sec
symbol incr	22759024.0 Ops/sec

Related benchmarks:

weakmap vs closure vs private symbols (version: 0)

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

Created: 5 years ago by: Guest

Jump to the latest result

closure get

weakmap get

closure incr

weakmap incr

symbol incr

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):