Benchmark: Map keyed by Object

Map keyed by Object (version: 5) Benchmark.js

Comparing different methods for using an arbitrary object as a Map key, for a relatively small number of entries. Used to make decisions about how to cache WrappedEnum instances in ts-enum-util: https://github.com/UselessPickles/ts-enum-util

Comparing performance of: `Polyfill Map by Object vs Native Map by Object vs Native Map by JSON vs Object by JSON vs Native WeakMap by Object`

Created: 8 years ago by: Registered User

Go to the latest result

Script Preparation code:

function SlowMap() {
  this._keys = [];
  this._values = [];
}

SlowMap.prototype = {
  set: function(key, value) {
    const index = this._keys.indexOf(key);
    if (index !== -1) {
      this._values[index] = value;
    } else {
      this._keys.push(key);
      this._values.push(value);
    }
  },
  
  get: function(key) {
    const index = this._keys.indexOf(key);
    if (index !== -1) {
      return this._values[index];
    } else {
      return undefined;
    }
  }
};

var OBJECT_COUNT = 500;
var PROPERTY_COUNT = 10;
var OBJECTS = [];

var slowMapByObj = new SlowMap();
var nativeMapByObj = new Map();
var nativeWeakMapByObj = new WeakMap();
var nativeMapByJson = new Map();
var objectMapByJson = {};

for (let i = 0; i < OBJECT_COUNT; ++i) {
  var obj = {};
  
  for (let j = 0; j < PROPERTY_COUNT; ++j) {
    obj[i + "|" + j] = i * PROPERTY_COUNT + j;
  }
  
  OBJECTS.push(obj);
  slowMapByObj.set(obj, i);
  nativeMapByObj.set(obj, i);
  nativeWeakMapByObj.set(obj, i);
  nativeMapByJson.set(JSON.stringify(obj), i);
  objectMapByJson[JSON.stringify(obj)] = i;
}

var testLoopCount = 0;

Tests:

Polyfill Map by Object
var result = slowMapByObj.get(OBJECTS[testLoopCount++ % OBJECT_COUNT]);
Native Map by Object
var result = nativeMapByObj.get(OBJECTS[testLoopCount++ % OBJECT_COUNT]);
Native Map by JSON
var result = nativeMapByJson.get(JSON.stringify(OBJECTS[testLoopCount++ % OBJECT_COUNT]));
Object by JSON
var result = objectMapByJson[JSON.stringify(OBJECTS[testLoopCount++ % OBJECT_COUNT])];
Native WeakMap by Object
var result = nativeWeakMapByObj.get(OBJECTS[testLoopCount++ % OBJECT_COUNT]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Polyfill Map by Object
Native Map by Object
Native Map by JSON
Object by JSON
Native WeakMap by Object

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 OPR/107.0.0.0

Browser/OS: Opera 107 on Windows

View result in a separate tab

Native WeakMap by Object

2.2M/s

Native Map by Object

2.0M/s

Polyfill Map by Object

1.8M/s

Native Map by JSON

580K/s

Object by JSON

567K/s

View exact numbers

Test name	Executions per second
✓ Native WeakMap by Object	2,173,918 Ops/sec
Native Map by Object	2,049,569 Ops/sec
Polyfill Map by Object	1,799,202 Ops/sec
Native Map by JSON	580,147 Ops/sec
Object by JSON	566,743 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, compared, and their pros and cons.

**Benchmark Definition**

The benchmark is designed to compare different methods for using an arbitrary object as a Map key, specifically focusing on performance. The test case creates an array of objects (`OBJECTS`) with a fixed number of properties (`PROPERTY_COUNT`), and then uses each object as a key in four different data structures:

1. `slowMapByObj`: A custom implementation of a Map using an object as a key.
2. `nativeMapByObj`: The built-in JavaScript `Map` data structure, which is designed to handle arbitrary keys.
3. `nativeWeakMapByObj`: The built-in JavaScript `WeakMap` data structure, which can handle references to objects as keys.
4. `nativeMapByJson`: A Map created using JSON stringification of the object as a key.
5. `objectMapByJson`: An object-based implementation where the JSON stringification of each object is used as a key.

**Comparison**

The test case measures the performance of each data structure by executing a loop that retrieves a value from each data structure using the object as a key. The benchmarking tool measures the number of executions per second for each data structure.

**Pros and Cons**

Here's a brief summary of the pros and cons of each data structure:

1. **slowMapByObj**: Custom implementation with performance implications.
	* Pros: Control over implementation, potentially optimized for specific use cases.
	* Cons: Performance overhead, potential bugs or optimization issues.
2. **nativeMapByObj**: Built-in JavaScript Map data structure.
	* Pros: High-performance, widely supported, and well-maintained.
	* Cons: May not handle arbitrary objects as keys efficiently (e.g., using `Object.prototype.toString()`).
3. **nativeWeakMapByObj**: Built-in JavaScript WeakMap data structure.
	* Pros: Efficient use of weak references, high performance.
	* Cons: May not be suitable for all scenarios, requires careful usage to avoid memory leaks.
4. **nativeMapByJson**: Map created using JSON stringification of the object as a key.
	* Pros: Simple implementation, potentially efficient due to caching.
	* Cons: Performance may degrade if the number of unique keys is low, and there's no built-in mechanism for handling collisions.

**Other Considerations**

When choosing between these data structures, consider the following factors:

* **Performance**: nativeMapByObj and nativeWeakMapByObj are likely to be the fastest options.
* **Memory Usage**: nativeWeakMapByObj can help prevent memory leaks if used carefully.
* **Scalability**: nativeMapByJson may not be suitable for large-scale applications with a low number of unique keys.

**Skipper's Conclusion**

In summary, this benchmark highlights the importance of choosing the right data structure based on performance requirements and specific use cases. While built-in JavaScript Map and WeakMap are recommended due to their high performance and efficiency, custom implementations like slowMapByObj may be suitable for specific scenarios with careful optimization and testing.

Please let me know if you have any further questions or need more clarification!