Benchmark: Object key access vs array finds

Script Preparation code:

var items = Array.from(Array(1000), (_,x) => ({key: x, value: x*10}));

var objContainer = {};
var arrContainer = [];
var mapContainer = new Map();

for (let i = 2000; i >= 0; i--) {
  const index = Math.floor(Math.random() * 1000);
  const item = items[index];
  objContainer[item.key] = item;
  arrContainer.push(item);
  mapContainer.set(item.key,item);
}

Tests:

object
items.forEach(item => objContainer[item.value])
map
items.forEach(item => mapContainer.get(item.value))
array
items.forEach(item => arrContainer.find(containerItem => containerItem.value === item.value))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
object
map
array

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):

LLMs can make mistakes. Check important info.

This benchmark tests the performance of different ways to access data in JavaScript.

**Options Compared:**

* **Object (`object` test):**  Uses an object where keys are unique identifiers (in this case, `item.key`) and values are the associated data objects (`item`). It accesses the data using key lookup (`objContainer[item.value]`).
* **Map (`map` test):** Uses a Map, which is specifically designed for key-value storage and retrieval. It retrieves data by key using `mapContainer.get(item.value)`.
* **Array with `find()` (`array` test):** Uses an array to store the data.  To find a specific item, it iterates through the array using `find()` and compares values until a match is found (`arrContainer.find(containerItem => containerItem.value === item.value)`).

**Pros and Cons:**

* **Object:** 
    * **Pro:** Can be very fast for direct key access if the keys are relatively evenly distributed.
    * **Con:**  Performance degrades as the number of keys increases because JavaScript objects use hash tables, which can have collisions leading to slower lookups.

* **Map:** 
    * **Pro:** Designed for efficient key-based lookup, with average constant time complexity (O(1)) for get operations.
    * **Con:**  Can be slightly more complex to work with than objects in some cases.

* **Array with `find()`:** 
    * **Pro:** Works well when you need to find an item based on a value rather than a unique key.
    * **Con:**  `find()` typically iterates through the entire array, making it less efficient for large arrays compared to objects or Maps.

**Other Considerations:**

* **Data Structure Choice:** The best choice depends heavily on how you access and use your data. If you frequently need to look up items by a unique key, a Map is often the most efficient option. If you have smaller datasets and know the keys will be relatively evenly distributed, objects can be fast.

* **Array Size:** For very large arrays (`find()` becomes slow), consider alternative methods like binary search if your data can be sorted.

Let me know if you'd like a deeper dive into any particular aspect of this benchmark!

Latest run results:

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

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

Browser/OS: Chrome 108 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
object	22798.9 Ops/sec
map	12105.4 Ops/sec
array	1468.3 Ops/sec

Related benchmarks:

Object key access vs array finds (version: 0)

Comparing performance of: object vs map vs array

Created: one year ago by: Guest

Jump to the latest result

object

map

array

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):