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

Go 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

Map.get, 10 000 elements

3.5M/s

Map.get, 1 000 000 elements

3.4M/s

Array.find, 10 000 elements

42K/s

Array.find, 10 lookups

5K/s

Array to Map + Map.get, 10 lookups

3K/s

Array to Map + Map.get, 100 lookups

3K/s

Array to Map + Map.get, 1 lookup

3K/s

Array.find, 100 lookups

525/s

Array.find, 1 000 000 elements

212/s

View exact numbers

Test name	Executions per second
✓ Map.get, 10 000 elements	3,452,761 Ops/sec
Map.get, 1 000 000 elements	3,352,398 Ops/sec
Array.find, 10 000 elements	41,766 Ops/sec
Array.find, 10 lookups	5,387 Ops/sec
Array to Map + Map.get, 10 lookups	3,113 Ops/sec
Array to Map + Map.get, 100 lookups	2,948 Ops/sec
Array to Map + Map.get, 1 lookup	2,880 Ops/sec
Array.find, 100 lookups	525 Ops/sec
Array.find, 1 000 000 elements	212 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.

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

Created: 2 years ago by: Registered User

Go 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>

Fastest: N/A

Slowest: N/A

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

Related benchmarks