Benchmark: custom WeakMap vs Symbol Property

Script Preparation code:

class CustomWeakMap {
  constructor(relationKey = '__relation') {
    this.relationKey = relationKey;
  }

  // 设置键值对 - 使用直接属性赋值以提高性能
  set(key, value) {
    key[this.relationKey] = value;
    return this;
  }

  // 获取键对应的值
  get(key) {
    return key[this.relationKey];
  }

  // 检查键是否存在
  has(key) {
    return this.relationKey in key;
  }

  // 删除键值对
  delete(key) {
    return delete key[this.relationKey];
  }
}
var to0 = {};
var to1 = {};
var to2 = {}
var wm = new WeakMap();
var sy = Symbol();
var cy = new CustomWeakMap();
wm.set(to1, 1);
to1[sy] = 1;
cy.set(to2,1)

Tests:

WeakMap set
wm.set(to0, 1);
Symbol Property set
to0[sy] = 1;
WeakMap get
let r = wm.get(to1);
Symbol Property get
let r = to1[sy];
CustomWeakMap set
cy.set(to2, 1);
CustomWeakMap get
let r = cy.get(to2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
WeakMap set
Symbol Property set
WeakMap get
Symbol Property get
CustomWeakMap set
CustomWeakMap get

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
WeakMap set	102614104.0 Ops/sec
Symbol Property set	173704560.0 Ops/sec
WeakMap get	97679648.0 Ops/sec
Symbol Property get	153358800.0 Ops/sec
CustomWeakMap set	167226688.0 Ops/sec
CustomWeakMap get	173829632.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

This benchmark compares three different approaches to key-value data storage in JavaScript:

1. **WeakMap**:
    - **Description**: `WeakMap` is a collection of key/value pairs that allows only objects as keys. In a `WeakMap`, the keys are "weakly referenced," meaning if there are no other references to a key object, it can be garbage collected.
    - **Pros**:
        - It automatically cleans up memory when keys are no longer needed, providing better memory management.
        - Ideal for associating metadata to existing objects without modifying the objects directly.
    - **Cons**:
        - Only objects can be used as keys (no primitives).
        - The absence of methods to iterate or retrieve all entries can be limiting.
    
2. **Symbol Property**:
    - **Description**: Symbols are a primitive data type in JavaScript, generally used to create unique identifiers for object properties. By assigning a value to an object using a symbol as the key, it prevents accidental naming collisions.
    - **Pros**:
        - Provides unique and non-enumerable property keys, ensuring that they won't conflict with properties created by other parts of code.
    - **Cons**:
        - Difficult to manage as they do not easily allow checking for existence or enumeration.
        - Memory management is manual; if the object is referenced elsewhere, the memory will not be freed.

3. **CustomWeakMap**:
    - **Description**: This is a user-defined class that mimics the functionality of `WeakMap` using regular property access on objects. The class uses a relation key to store associated values.
    - **Pros**:
        - Allows customization and possible optimization of operations; for example, it directly alters object properties.
        - Offers similar functionality to the `WeakMap`, but the user has control over implementation and can optimize specific use cases.
    - **Cons**:
        - Lacks built-in memory management capabilities; it depends solely on the garbage collector behavior for the objects being manipulated.
        - Potential for memory leaks if not carefully managed.

### Performance Comparison of Benchmark Cases
#### 1. Set Operations
- **WeakMap set**: It recorded an execution rate of 102614104.0 operations per second. This implementation incurs overhead due to its internal structure and mechanics.
- **Symbol Property set**: This operation performed slightly better, at 173704560.0 operations per second, since it directly modifies the object property, making it less computationally intensive.
- **CustomWeakMap set**: Closely matches Symbol performance at 167226688.0. Its direct approach to property assignment balances well with similar operational speed.

#### 2. Get Operations
- **WeakMap get**: This showed the worst performance at 97679648.0 operations per second, likely due to additional internal checks and structures.
- **Symbol Property get**: Performed better than `WeakMap` but slower than custom implementations at 153358800.0 operations per second.
- **CustomWeakMap get**: Achieved the best performance at 173829632.0 operations per second, benefiting from direct property access.

### Conclusion and Alternatives
The results indicate that while `WeakMap` provides significant advantages in memory management, it may not perform as well as the direct approaches (using symbols or custom implementations). If memory management and automatic cleanup are not as critical for the application's logic, the custom `WeakMap` implementation and symbol properties offer competitive performance with the added advantage of flexibility in handling keys.

Other alternatives to consider for key-value data storage in JavaScript include using plain objects for simple mapping requirements, or third-party libraries such as `Immutable.js` or `Lodash`, which offer functional data structures that can provide performance benefits and extra functionality depending on your use case.

Related benchmarks:

custom WeakMap vs Symbol Property (version: 2)

Comparing performance of: WeakMap set vs Symbol Property set vs WeakMap get vs Symbol Property get vs CustomWeakMap set vs CustomWeakMap get

Created: one month ago by: Registered User

Jump to the latest result

WeakMap set

Symbol Property set

WeakMap get

Symbol Property get

CustomWeakMap set

CustomWeakMap get

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):