Benchmark: WeakMap vs property access vs symbol access

Script Preparation code:

var weakMap = new WeakMap()
var symbol = Symbol('next');
var prop = 'a';

var object = { [prop]: 1, [symbol]: 1 };
weakMap.set(object, 1);

Tests:

WeakMap.get
weakMap.get(weakMap)
object[prop]
object[prop]
object[symbol]
object[symbol]
object.a
object.a

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
WeakMap.get
object[prop]
object[symbol]
object.a

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 days ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
WeakMap.get	101816112.0 Ops/sec
object[prop]	159054288.0 Ops/sec
object[symbol]	165747584.0 Ops/sec
object.a	180112784.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark provided focuses on comparing different methods of accessing properties of an object in JavaScript, specifically through:

1. **WeakMap**: Using the `WeakMap` data structure to access an associated value.
2. **Property Access via String**: Accessing object properties using a string key.
3. **Property Access via Symbol**: Accessing object properties using a `Symbol` key.
4. **Direct Property Access**: Accessing object properties directly by their identifier.

### Options Compared

1. **WeakMap**:
   - **Usage**: `weakMap.get(object)` retrieves the value associated with `object` in the `WeakMap`.
   - **Pros**: Enables garbage collection for objects after they become unreachable, which helps in memory management.
   - **Cons**: Slightly slower compared to direct property access methods due to the overhead of the data structure.

2. **Property Access via String**:
   - **Usage**: `object[prop]` uses the variable `prop`, which is dynamically evaluated to access the property.
   - **Pros**: Provides flexibility, allowing for dynamic property names.
   - **Cons**: Slightly slower than direct property access since it involves parsing the string at runtime.

3. **Property Access via Symbol**:
   - **Usage**: `object[symbol]` retrieves the value associated with the `Symbol`.
   - **Pros**: Symbols are unique and provide a way to define properties that won’t conflict with others. They also help keep certain properties private.
   - **Cons**: Similar to string access in terms of performance and complexity. Additionally, Symbols can be less intuitive compared to standard string-based property access.

4. **Direct Property Access**:
   - **Usage**: `object.a` directly accesses the property `a`.
   - **Pros**: This is the most straightforward and fastest way to access object properties in JavaScript.
   - **Cons**: Doesn’t allow dynamic property names.

### Benchmark Results

The results provide execution speeds for each method:

- **Direct Property Access (`object.a`)**: 21,143,698 executions per second (fastest).
- **Property Access via String (`object[prop]`)**: 11,594,823 executions per second.
- **Property Access via Symbol (`object[symbol]`)**: 11,511,950 executions per second.
- **WeakMap Access (`weakMap.get`)**: 11,108,025 executions per second (slowest).

### Other Considerations

- **Performance**: As shown, direct property access is generally the fastest. For high-performance needs, minimizing the use of WeakMaps, Symbols, and dynamic string access might be advisable.
- **Memory Management**: Despite performance considerations, WeakMaps provide significant advantages when it comes to managing memory, especially in cases where an object's lifecycle needs to be closely tracked.
- **Private Properties**: Using Symbols can be beneficial for defining “private” properties since they are not easily accessible with standard enumeration, thus helping to encapsulate data better.

### Alternatives

Other alternatives for property access could include:

- **Map**: Unlike `WeakMap`, a `Map` can hold references to keys even when they are not in use anymore. This could be helpful but at the cost of potential memory leaks.
- **Proxies**: Using the `Proxy` API allows for custom behavior when accessing properties, but it may introduce additional overhead in performance.
- **Class Properties**: In class-based code, properties can be better organized using JavaScript's class syntax, which can encapsulate data more effectively.

### Conclusion

This benchmark gives insight into the trade-offs between different property access methods in JavaScript. While the performance results favor direct access, the choice of property access strategy should also take into account the specific use case, memory management needs, and the desired level of property encapsulation.

Related benchmarks:

WeakMap vs property access vs symbol access (version: 2)

Comparing performance of: WeakMap.get vs object[prop] vs object[symbol] vs object.a

Created: 2 months ago by: Registered User

Jump to the latest result

WeakMap.get

object[prop]

object[symbol]

object.a

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):