Benchmark: Array.find vs. Map.getdfsxcz

Array.find vs. Map.getdfsxcz (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: one year 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);

​x
 
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(9999); array_small.find(el => el.id === target);
const target = getRandomInt(9999);
array_small.find(el => el.id === target);
Map.get, 10 000 elements
const target = getRandomInt(9999); map_small.get(target);
const target = getRandomInt(9999);
map_small.get(target);
Array.find, 1 000 000 elements
const target = getRandomInt(999999); array_large.find(el => el.id === target);
const target = getRandomInt(999999);
array_large.find(el => el.id === target);
Map.get, 1 000 000 elements
const target = getRandomInt(999999); map_large.get(target)
const target = getRandomInt(999999);
map_large.get(target)
Array to Map + Map.get, 1 lookup
const map = arrayToMap(array_small); const target = getRandomInt(9999); map.get(target);
const map = arrayToMap(array_small);
const target = 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 = getRandomInt(9999); map.get(target); }
const map = arrayToMap(array_small);

for (let i = 0; i < 10; i++) {
const target = 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 = getRandomInt(9999); map.get(target); }
const map = arrayToMap(array_small);

for (let i = 0; i < 100; i++) {
const target = getRandomInt(9999);
map.get(target);
}
Array.find, 10 lookups
for (let i = 0; i < 10; i++) { const target = getRandomInt(9999); array_small.find(el => el.id === target) }
for (let i = 0; i < 10; i++) {
const target = getRandomInt(9999);
array_small.find(el => el.id === target)
}
Array.find, 100 lookups
for (let i = 0; i < 100; i++) { const target = getRandomInt(9999); array_small.find(el => el.id === target) }
for (let i = 0; i < 100; i++) {
const target = getRandomInt(9999);
array_small.find(el => el.id === target)
}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: one year ago)

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/117.0

Browser/OS: Firefox 117 on Ubuntu

View result in a separate tab

Test name	Executions per second
Array.find, 10 000 elements	30334578.0 Ops/sec
Map.get, 10 000 elements	1126225920.0 Ops/sec
Array.find, 1 000 000 elements	15867060.0 Ops/sec
Map.get, 1 000 000 elements	1099068160.0 Ops/sec
Array to Map + Map.get, 1 lookup	1876891.1 Ops/sec
Array to Map + Map.get, 10 lookups	1894195.1 Ops/sec
Array to Map + Map.get, 100 lookups	1637980.6 Ops/sec
Array.find, 10 lookups	3035343.0 Ops/sec
Array.find, 100 lookups	236440.8 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 5 months ago):

Let's break down the test cases and explain what is being tested.

Overview

The test cases compare the performance of two approaches: Array.find and Map.get. The tests are designed to measure the execution time of these methods for different scenarios, such as varying array sizes and the number of lookups.

What is being compared?

Array.find: A method that searches for an element in an array based on a predicate function.
Map.get: A method that retrieves the value associated with a given key from a Map object.

Options compared

The tests compare the performance of these two methods under different conditions:

Array size: Small arrays (2 elements) and large arrays (5 elements or 1,000,000 elements)
Number of lookups:
- Single lookup
- Multiple lookups (10, 100)

Test cases

Each test case measures the execution time of one of the two methods under the specified conditions. The results are reported as executions per second.

For example, the first test case measures the execution time of Array.find for a small array with 10,000 elements.

Interpretation of results

The test results show that:

Map.get is generally faster than Array.find, especially for large arrays.
As the number of lookups increases, Map.get remains faster.
For small arrays, Array.find may be slightly faster due to caching or other optimizations.

Device and OS

All tests are run on a desktop device with an Ubuntu operating system and running Firefox 117. The results are reported for this specific configuration.

Conclusion

The test cases aim to measure the performance difference between Array.find and Map.get under various conditions, providing insights into which method is more efficient in different scenarios.

LLMs can make mistakes. Check important info.

Let's break down the test cases and explain what is being tested.

**Overview**

The test cases compare the performance of two approaches: `Array.find` and `Map.get`. The tests are designed to measure the execution time of these methods for different scenarios, such as varying array sizes and the number of lookups.

**What is being compared?**

1. **Array.find**: A method that searches for an element in an array based on a predicate function.
2. **Map.get**: A method that retrieves the value associated with a given key from a Map object.

**Options compared**

The tests compare the performance of these two methods under different conditions:

* Array size: Small arrays (2 elements) and large arrays (5 elements or 1,000,000 elements)
* Number of lookups:
	+ Single lookup
	+ Multiple lookups (10, 100)

**Test cases**

Each test case measures the execution time of one of the two methods under the specified conditions. The results are reported as executions per second.

For example, the first test case measures the execution time of `Array.find` for a small array with 10,000 elements.

**Interpretation of results**

The test results show that:

* `Map.get` is generally faster than `Array.find`, especially for large arrays.
* As the number of lookups increases, `Map.get` remains faster.
* For small arrays, `Array.find` may be slightly faster due to caching or other optimizations.

**Device and OS**

All tests are run on a desktop device with an Ubuntu operating system and running Firefox 117. The results are reported for this specific configuration.

**Conclusion**

The test cases aim to measure the performance difference between `Array.find` and `Map.get` under various conditions, providing insights into which method is more efficient in different scenarios.

Related benchmarks: