Benchmark: Array.find vs. Map.get (string) fixes

Array.find vs. Map.get (string) fixes (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: 2 years ago by: Registered User

Jump to the latest result

Script Preparation code:

function getRandomElement(id) {
  return {
    id: String(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(10000);
array_large = getArray(1000000);

map_small = arrayToMap(array_small);
map_large = arrayToMap(array_large);

Tests:

Array.find, 10 000 elements
const target = String(getRandomInt(9999)); array_small.find(el => el.id === target);
Map.get, 10 000 elements
const target = String(getRandomInt(9999)); map_small.get(target);
Array.find, 1 000 000 elements
const target = String(getRandomInt(999999)); array_large.find(el => el.id === target);
Map.get, 1 000 000 elements
const target = String(getRandomInt(999999)); map_large.get(target)
Array to Map + Map.get, 1 lookup
const map = arrayToMap(array_small); const target = String(getRandomInt(9999)); map.get(target);
Array to Map + Map.get, 10 lookups
const map = arrayToMap(array_small); for (let i = 0; i < 10; i++) { const target = String(getRandomInt(9999)); map.get(target); }
Array to Map + Map.get, 100 lookups
const map = arrayToMap(array_small); for (let i = 0; i < 100; i++) { const target = String(getRandomInt(9999)); map.get(target); }
Array.find, 10 lookups
for (let i = 0; i < 10; i++) { const target = String(getRandomInt(9999)); array_small.find(el => el.id === target) }
Array.find, 100 lookups
for (let i = 0; i < 100; i++) { const target = String(getRandomInt(9999)); 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

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 124 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.find, 10 000 elements	41766.0 Ops/sec
Map.get, 10 000 elements	3452761.2 Ops/sec
Array.find, 1 000 000 elements	212.3 Ops/sec
Map.get, 1 000 000 elements	3352398.2 Ops/sec
Array to Map + Map.get, 1 lookup	2879.5 Ops/sec
Array to Map + Map.get, 10 lookups	3112.6 Ops/sec
Array to Map + Map.get, 100 lookups	2948.2 Ops/sec
Array.find, 10 lookups	5386.7 Ops/sec
Array.find, 100 lookups	525.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the data.

The test cases involve different JavaScript operations:

1. `Map.get`
2. `Array.find` with varying number of lookups (10, 100, or 1,000,000)
3. Array to Map and subsequent Map.get operations with different numbers of lookups (10, 100, or 1)

The results are measured in executions per second (`ExecutionsPerSecond`).

To provide a concise answer, I'll highlight the findings:

* `Map.get` is relatively fast, with execution times ranging from approximately 0.04 to 14 seconds.
* `Array.find` is significantly slower than `Map.get`, with execution times ranging from several milliseconds (e.g., for 10 lookups) to tens of thousands of seconds (e.g., for 1,000,000 elements).
* The performance difference between `Array.find` and `Array.toMap` + `Map.get` is noticeable, but it's not dramatic.

Some specific observations:

* Chrome 124, on a Mac with Intel Mac OS X 10.15.7, performs relatively well across these test cases.
* Execution times for certain operations (e.g., `Map.get`) are consistent or similar across different numbers of lookups.
* The vast majority of execution time is attributed to `Array.find`, which can be an issue in performance-critical applications.

Keep in mind that the performance results may vary depending on your specific use case, data distribution, and implementation details.

Related benchmarks: