Performance comparison between Javascript Object and Map/Set for key lookup

Question

Performance comparison between Javascript Object and Map/Set for key lookup

I decided to experiment with the performance of JavaScript Object, Map, and Set when it comes to accessing keys. I tested the following three code snippets on JSBEN.CH.

Objects

const object = {};

for (let i = 0; i < 10000; ++i) {
    object[`key_${i}`] = 1;
}

let result = 0;
  
for (let i = 0; i < 10000; ++i) {
    result += object[`key_${i}`];
}

Maps

const map = new Map();

for (let i = 0; i < 10000; ++i) {
    map.set(`key_${i}`, 1);
}

let result = 0;

for (let i = 0; i < 10000; ++i) {
    result += map.get(`key_${i}`);
}

Sets

const set = new Set();

for (let i = 0; i < 10000; ++i) {
    set.add(`key_${i}`);
}

let result = 0;

for (let i = 0; i < 10000; ++i) {
    result += set.has(`key_${i}`);
}

Upon inspecting the results from the test link, it appears that while Map and Set display similar performance, Objects consistently perform slower in comparison. What could be causing this discrepancy where Objects are less efficient than Map or Set for basic key access operations?

Edit 1: Not only is accessing keys slower with Object, but setting keys is also shown to be slower than with Map or Set.

javascript performance dictionary object set

Answer 1

Answer №1

It's risky to rely solely on relative numbers when analyzing performance. Here are some absolute values from tests run on NodeJS v14.14.0 with an Intel 8350U processor:

Iterations	Object write	Object read	Map write	Map read
100	0ms	0ms	0ms	0ms
1,000	3ms	1ms	0ms	0ms
10,000	7ms	4ms	8ms	1ms
1,000,000	1222ms	527ms	632ms	542ms

Comparing objects and maps for 10,000 iterations shows just a 1-millisecond difference in the test results, which is within the margin of error. Therefore, no definitive conclusion can be drawn based on this test data as the results appear random.

For 1 million iterations, map writes outperform object writes significantly, while read performance remains similar between the two. Despite the slower object writes, reaching one million writes/s suggests that this aspect may not likely be the bottleneck in your application.

To understand the underlying processes better, examining the engine's bytecode by running node --print-code would provide valuable insights. An analysis reveals:

If an object is constructed using Object.create(null) without a prototype, there is minimal impact on performance, indicating that prototype lookup does not affect overall efficiency.
After the 20th iteration, V8 switches to using dictionary_map as the internal representation for objects, essentially pitting one hash map against another hashmap (accessible via node --allow-natives-syntax and executing %DebugPrint(object)).

Below is the benchmark code used for these tests:

function benchmark(TIMES) {  
  console.log("BENCHMARK ", TIMES);

  const object = Object.create(null);

    let start = Date.now();
    for (let i = 0; i < TIMES; ++i) {
        object[`key_${i}`] = 1;
    }

    console.log("Object write took", Date.now() - start);
    start = Date.now();

    let result = 0;
  
    for (let i = 0; i < TIMES; ++i) {
      result += object[`key_${i}`];
    }

    console.log("Object read took", Date.now() - start);
    start = Date.now();

  


  const map = new Map();
  
  for (let i = 0; i < TIMES; ++i) {
    map.set(`key_${i}`, 1);
  }
  
  console.log("Map write took", Date.now() - start);
  start = Date.now();

  result = 0;
  
  for (let i = 0; i < TIMES; ++i) {
    result += map.get(`key_${i}`);
  }

  console.log("Map read took", Date.now() - start);

}

benchmark(100);
benchmark(1_000);
benchmark(10_000);
benchmark(1_000_000);

In summary:

Opt for Maps for dictionaries with numerous varied keys that change frequently, as they slightly outperform objects internally represented as hash tables.
Choose Objects for scenarios involving a small number of keys with frequent access, as Objects offer faster processing due to inline caching, hidden classes with fixed memory layout, etc.

Answer 2

It's risky to rely solely on relative numbers when analyzing performance. Here are some absolute values from tests run on NodeJS v14.14.0 with an Intel 8350U processor:

Iterations	Object write	Object read	Map write	Map read
100	0ms	0ms	0ms	0ms
1,000	3ms	1ms	0ms	0ms
10,000	7ms	4ms	8ms	1ms
1,000,000	1222ms	527ms	632ms	542ms

Comparing objects and maps for 10,000 iterations shows just a 1-millisecond difference in the test results, which is within the margin of error. Therefore, no definitive conclusion can be drawn based on this test data as the results appear random.

For 1 million iterations, map writes outperform object writes significantly, while read performance remains similar between the two. Despite the slower object writes, reaching one million writes/s suggests that this aspect may not likely be the bottleneck in your application.

To understand the underlying processes better, examining the engine's bytecode by running node --print-code would provide valuable insights. An analysis reveals:

If an object is constructed using Object.create(null) without a prototype, there is minimal impact on performance, indicating that prototype lookup does not affect overall efficiency.
After the 20th iteration, V8 switches to using dictionary_map as the internal representation for objects, essentially pitting one hash map against another hashmap (accessible via node --allow-natives-syntax and executing %DebugPrint(object)).

Below is the benchmark code used for these tests:

function benchmark(TIMES) {  
  console.log("BENCHMARK ", TIMES);

  const object = Object.create(null);

    let start = Date.now();
    for (let i = 0; i < TIMES; ++i) {
        object[`key_${i}`] = 1;
    }

    console.log("Object write took", Date.now() - start);
    start = Date.now();

    let result = 0;
  
    for (let i = 0; i < TIMES; ++i) {
      result += object[`key_${i}`];
    }

    console.log("Object read took", Date.now() - start);
    start = Date.now();

  


  const map = new Map();
  
  for (let i = 0; i < TIMES; ++i) {
    map.set(`key_${i}`, 1);
  }
  
  console.log("Map write took", Date.now() - start);
  start = Date.now();

  result = 0;
  
  for (let i = 0; i < TIMES; ++i) {
    result += map.get(`key_${i}`);
  }

  console.log("Map read took", Date.now() - start);

}

benchmark(100);
benchmark(1_000);
benchmark(10_000);
benchmark(1_000_000);

In summary:

Opt for Maps for dictionaries with numerous varied keys that change frequently, as they slightly outperform objects internally represented as hash tables.
Choose Objects for scenarios involving a small number of keys with frequent access, as Objects offer faster processing due to inline caching, hidden classes with fixed memory layout, etc.

Performance comparison between Javascript Object and Map/Set for key lookup

Answer №1

Similar questions

Learn how to display every ASCII or EBCDIC character once radio buttons have been selected

It seems that there is a null value being returned in the midst of the

A discrepancy has arisen as the value within the array structure is being altered

Employing JavaScript for fading divs in and out sequentially

Modifying the disabled attribute of an input tag upon button click in Angular 2

What is the correct way to start a typed Object in TypeScript/Angular?

Creating a Python server for an Angularjs application and capturing user input

Performance issues with Datatables server side processing

A pale tooltip with a light arrow appearing against a soft white backdrop

Retrieve information from an external JSON file and display it in a jstree

The ng-if directive in AngularJS seems to be malfunctioning

Hiding the style tag in the head section of a Laravel-Vue.js application with Vue.js

How can I efficiently utilize HTML/CSS/JS to float items and create a grid that accommodates expandable items while minimizing wasted space?

The random quote generator or current tweet quote feature is malfunctioning

Tips for achieving expansion of solely the clicked item and not the whole row

Extract key/value pairs from a JSON array by eliminating any HTML tags

Tips on assigning a data-id attribute

What is causing the local storage to not persist after refreshing the page?

JavaScript - Matching overlapping time intervals

Failure to trigger Summernote's OnImageUpload function