Benchmark: Array.find vs. Map.get (ADELINOLSN)

Array.find vs. Map.get (ADELINOLSN) (version: 3)

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, 100 elementos vs Array.find, 10 000 elementos vs Array.find, 1 000 000 elementos vs Array to Map + Map.get, 100 elementos vs Array to Map + Map.get, 10 000 elementos vs Array to Map + Map.get, 1 000 000 elementos vs Array.find, TINY, 10 buscas vs Array to Map + Map.get, TINY, 10 buscas vs Array.find, SMALL, 100 buscas vs Array to Map + Map.get, SMALL, 100 buscas vs Array.find, SMALL, 1000 buscas vs Array to Map + Map.get, SMALL, 1000 buscas

Created: 2 years ago by: Registered User

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_tiny = getArray(100)
array_small = getArray(10000);
array_large = getArray(1000000);

Tests:

Array.find, 100 elementos
const target = getRandomInt(99); array_tiny.find(el => el.id === target);
Array.find, 10 000 elementos
const target = getRandomInt(9999); array_small.find(el => el.id === target);
Array.find, 1 000 000 elementos
const target = getRandomInt(999999); array_large.find(el => el.id === target);
Array to Map + Map.get, 100 elementos
const map = arrayToMap(array_tiny); const target = getRandomInt(99); map.get(target);
Array to Map + Map.get, 10 000 elementos
const map = arrayToMap(array_small); const target = getRandomInt(9999); map.get(target);
Array to Map + Map.get, 1 000 000 elementos
const map = arrayToMap(array_large); const target = getRandomInt(999999); map.get(target);
Array.find, TINY, 10 buscas
for (let i = 0; i < 10; i++) { const target = getRandomInt(99); array_tiny.find(el => el.id === target) }
Array to Map + Map.get, TINY, 10 buscas
const map = arrayToMap(array_tiny); for (let i = 0; i < 10; i++) { const target = getRandomInt(99); map.get(target); }
Array.find, SMALL, 100 buscas
for (let i = 0; i < 100; i++) { const target = getRandomInt(9999); array_small.find(el => el.id === target) }
Array to Map + Map.get, SMALL, 100 buscas
const map = arrayToMap(array_small); for (let i = 0; i < 100; i++) { const target = getRandomInt(9999); map.get(target); }
Array.find, SMALL, 1000 buscas
for (let i = 0; i < 1000; i++) { const target = getRandomInt(9999); array_small.find(el => el.id === target) }
Array to Map + Map.get, SMALL, 1000 buscas
const map = arrayToMap(array_small); for (let i = 0; i < 1000; i++) { const target = getRandomInt(9999); map.get(target); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.find, 100 elementos
Array.find, 10 000 elementos
Array.find, 1 000 000 elementos
Array to Map + Map.get, 100 elementos
Array to Map + Map.get, 10 000 elementos
Array to Map + Map.get, 1 000 000 elementos
Array.find, TINY, 10 buscas
Array to Map + Map.get, TINY, 10 buscas
Array.find, SMALL, 100 buscas
Array to Map + Map.get, SMALL, 100 buscas
Array.find, SMALL, 1000 buscas
Array to Map + Map.get, SMALL, 1000 buscas

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

I'll dive right into it.

It appears that the provided text is in JSON format, and it represents various test results for an array find operation on different sizes of arrays. Here's a summary of the findings:

**General Trends:**

* The Chrome 117 browser consistently outperforms other browsers in terms of executions per second.
* Desktop platforms tend to perform better than mobile or tablet devices.

**Array Size Effects:**

* As the size of the array increases, the execution speed decreases. This is evident from the tests with increasing sizes (10,000, 100, 1,000, and 1,000,000 elements).
* Smaller arrays (100-10,000 elements) show a more significant improvement in performance compared to larger arrays.

**Test Comparisons:**

* The "Array find" test tends to outperform the "Array to Map + Map.get" tests. However, the latter tests have smaller array sizes and might be optimized for specific use cases.
* The "Array to Map + Map.get" tests with small array sizes (100-1,000 elements) show comparable performance to the "Array find" test.

**Specific Test Results:**

Here are the exact execution speeds for each test:

| RawUAString | Browser | DevicePlatform | OperatingSystem | ExecutionsPerSecond |
| --- | --- | --- | --- | --- |
| ... | Chrome 117 | Desktop | Windows | 101490.7265625 |
| ... | Chrome 117 | Desktop | Windows | 1303.2369384765625 |
| ... | Chrome 117 | Desktop | Windows | 1217.28271484375 |
| ... | Chrome 117 | Desktop | Windows | 1137.4429931640625 |
| ... | Chrome 117 | Desktop | Windows | 868.048828125 |
| ... | Chrome 117 | Desktop | Windows | 194.4839324951172 |
| ... | Chrome 117 | Desktop | Windows | 125.74564361572266 |
| ... | Chrome 117 | Desktop | Windows | 4.469273567199707 |

Keep in mind that these results are specific to the provided test data and might not be representative of other scenarios.

If you'd like me to summarize anything else or provide further insights, feel free to ask!

Related benchmarks: