Benchmark: Array.find vs. Map.get with very little items

Array.find vs. Map.get with very little items (version: 0)

Test the performance of Array.find vs. Map.get, with various array sizes, and with/without conversion from array to map

Comparing performance of: Array.find, 10 000 elements vs Map.get, 10 000 elements vs Array.find, 1 000 000 elements vs Map.get, 1 000 000 elements vs Array to Map + Map.get, 1 lookup vs Array to Map + Map.get, 10 lookups vs Array to Map + Map.get, 100 lookups vs Array.find, 10 lookups vs Array.find, 100 lookups

Created: 9 months ago by: Guest

Jump to the latest result

Script Preparation code:

function getRandomElement(id) {
  return {
    id,
    a: Math.random(),
    b: Math.random(),
    c: Math.random(),
  }
}

function getArray(length) {
  const result = [];
  for (let i = 0; i < length; i++) {
    result.push(getRandomElement(i))
  }
  
  return result;
}

function arrayToMap(array) {
  return new Map(array.map(el => [el.id, el]));
}

function getRandomInt(max) {
  return Math.floor(Math.random() * max);
}

array_small = getArray(2);
array_large = getArray(5);

map_small = arrayToMap(array_small);
map_large = arrayToMap(array_large);

Tests:

Array.find, 10 000 elements
const target = getRandomInt(3); array_small.find(el => el.id === target);
Map.get, 10 000 elements
const target = getRandomInt(3); map_small.get(target);
Array.find, 1 000 000 elements
const target = getRandomInt(6); array_large.find(el => el.id === target);
Map.get, 1 000 000 elements
const target = getRandomInt(6); map_large.get(target)
Array to Map + Map.get, 1 lookup
const map = arrayToMap(array_small); const target = getRandomInt(3); map.get(target);
Array to Map + Map.get, 10 lookups
const map = arrayToMap(array_small); for (let i = 0; i < 10; i++) { const target = getRandomInt(3); map.get(target); }
Array to Map + Map.get, 100 lookups
const map = arrayToMap(array_small); for (let i = 0; i < 100; i++) { const target = getRandomInt(3); map.get(target); }
Array.find, 10 lookups
for (let i = 0; i < 10; i++) { const target = getRandomInt(3); array_small.find(el => el.id === target) }
Array.find, 100 lookups
for (let i = 0; i < 100; i++) { const target = getRandomInt(3); array_small.find(el => el.id === target) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.find, 10 000 elements
Map.get, 10 000 elements
Array.find, 1 000 000 elements
Map.get, 1 000 000 elements
Array to Map + Map.get, 1 lookup
Array to Map + Map.get, 10 lookups
Array to Map + Map.get, 100 lookups
Array.find, 10 lookups
Array.find, 100 lookups

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark test cases and explanations.

**Benchmark Test Cases:**

The test cases are designed to compare the performance of two approaches:

1. `Array.find()`
2. `Map.get()` with and without conversion from an array to a map.

There are four variations of `Map.get()`:

a. Single lookup
b. 10 lookups
c. 100 lookups

Each test case measures the executions per second for each approach on different data sizes (10,000 elements and 1,000,000 elements).

**Approach 1: Array.find()**

`Array.find()` is a method that searches for an element in an array and returns its index if found. The performance of this method depends on the size of the array and the efficiency of the underlying data structure.

**Approach 2: Map.get() with conversion to map**

Converting an array to a map involves creating a new data structure that maps each unique value in the array to a key. This process can be expensive, especially for large arrays.

The `Map.get()` method is then used to look up values in this map. The performance of this approach depends on the size of the map and the efficiency of the underlying data structure.

**Comparison:**

The test results show that `Array.find()` performs better than `Map.get()` with conversion to map for both small and large datasets. This is because `Array.find()` has a lower overhead compared to creating and searching in a map.

However, when using `Map.get()` without conversion (i.e., directly on the array), the performance is closer to that of `Array.find()`. This is likely due to the fact that the array's underlying data structure is optimized for fast lookups.

**Key Takeaways:**

* For most use cases, `Array.find()` is a better choice than using `Map.get()` with conversion to map.
* When working with large datasets, using `Map.get()` without conversion can provide competitive performance.
* Conversion from an array to a map can introduce significant overhead, making it less suitable for high-performance applications.

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 121 on Android

View result in a separate tab

Test name	Executions per second
Array.find, 10 000 elements	903891.2 Ops/sec
Map.get, 10 000 elements	853215.4 Ops/sec
Array.find, 1 000 000 elements	810190.6 Ops/sec
Map.get, 1 000 000 elements	891435.4 Ops/sec
Array to Map + Map.get, 1 lookup	546047.6 Ops/sec
Array to Map + Map.get, 10 lookups	113249.1 Ops/sec
Array to Map + Map.get, 100 lookups	12191.9 Ops/sec
Array.find, 10 lookups	84737.0 Ops/sec
Array.find, 100 lookups	7955.6 Ops/sec

Related benchmarks:

Array.find vs. Map.get with very little items (version: 0)

Test the performance of Array.find vs. Map.get, with various array sizes, and with/without conversion from array to map

Created: 9 months ago by: Guest

Jump to the latest result

Array.find, 10 000 elements

Map.get, 10 000 elements

Array.find, 1 000 000 elements

Map.get, 1 000 000 elements

Array to Map + Map.get, 1 lookup

Array to Map + Map.get, 10 lookups

Array to Map + Map.get, 100 lookups

Array.find, 10 lookups

Array.find, 100 lookups

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):