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

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

closure get

28.2M/s

symbol incr

28.0M/s

closure incr

27.6M/s

weakmap get

13.1M/s

weakmap incr

8.4M/s

Fastest: closure get (3.4x faster)

View exact numbers

✓ closure get: 28,150,444 ops/sec
• symbol incr: 28,029,070 ops/sec
• closure incr: 27,556,226 ops/sec
• weakmap get: 13,089,012 ops/sec
• weakmap incr: 8,385,952 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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

Latest run results:

Run details: (Test run date: 5 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36

Browser/OS: Chrome 146 on Mac OS X 10.15.7

View result in a separate tab

closure get

100.6M/s

symbol incr

98.4M/s

closure incr

90.4M/s

weakmap get

55.1M/s

weakmap incr

39.7M/s

View exact numbers

Test name	Executions per second
✓ closure get	100,550,352 Ops/sec
symbol incr	98,401,080 Ops/sec
closure incr	90,378,728 Ops/sec
weakmap get	55,057,148 Ops/sec
weakmap incr	39,708,256 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 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.

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

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

Created: 7 years ago by: Guest

Go to the latest result

closure get

weakmap get

closure incr

weakmap incr

symbol incr

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

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 (version: 0) Benchmark.js

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

Created: 7 years ago by: Guest

Go to the latest result

closure get

weakmap get

closure incr

weakmap incr

symbol incr

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

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`