Benchmark: Map key access vs array find

Script Preparation code:

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

Tests:

Array find
items.forEach(item => arrContainer.find(containerItem => containerItem.value === item.value))
Map access
items.forEach(item => objContainer.get(item.value))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array find
Map access

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 8 months ago)

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

Browser/OS: Chrome 123 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array find	1234.4 Ops/sec
Map access	13112.9 Ops/sec

Autogenerated LLM Summary (model gemma2:9b, generated 2 months ago):

LLMs can make mistakes. Check important info.

This benchmark compares the performance of accessing data within a JavaScript `Map` versus searching for data in an array using `find`.

Let's break down what each test case does:

**Test Case 1: "Array find"**

*   The code iterates through an array (`items`) and for each item, it uses the `find` method on the `arrContainer` array. 
*   `find` searches for an element within the array that matches a specific condition (in this case, matching the value of the current item in `items`).

**Test Case 2: "Map access"**

*   This test case iterates through the same `items` array.
*   For each item, it uses `objContainer.get(item.value)` to directly retrieve the associated value from the `Map`.  Maps are designed for fast key-based lookups.

**Pros and Cons:**

*   **Array find:** 
    *   **Pro:** More versatile; can search based on complex conditions using a callback function within `find`.
    *   **Con:** Linear time complexity - the worst-case scenario involves iterating through the entire array.  Less efficient for large datasets.

*   **Map access:**
    *   **Pro:**  Near constant time complexity (O(1)) for retrieving values by key. Extremely efficient for frequent lookups.
    *   **Con:** Less flexible than `find` when searching based on complex criteria.

**Other Considerations:**

*   **Dataset Size:** For small datasets, the performance difference might be negligible. 
*   **Search Frequency:** If you need to frequently retrieve values by key, Maps are generally a better choice due to their constant-time access.

Let me know if you have any other questions.

Related benchmarks:

Map key access vs array find (version: 0)

Comparing performance of: Array find vs Map access

Created: 2 years ago by: Guest

Jump to the latest result

Array find

Map access

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated 2 months ago):