Benchmark: SJ - Array.find vs. Map.get

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(100);
array_large = getArray(10000);

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);
Map.get, 10 000 elements
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);
Map.get, 1 000 000 elements
const target = getRandomInt(999999); map_large.get(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

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what is being tested on MeasureThat.net.

**Benchmark Definition**

The benchmark is testing the performance of two methods:

1. `Array.find()`: This method finds the first element in an array that satisfies the provided condition.
2. `Map.get()` : This method returns the value associated with a given key in a Map object.

**Options Compared**

The benchmark compares the execution time of these two methods on arrays and Maps of varying sizes:

* Small arrays with 10,000 elements
* Large arrays with 1,000,000 elements

Additionally, it tests whether converting an array to a map affects performance.

**Pros and Cons**

Here are some pros and cons of each approach:

* `Array.find()`:
	+ Pros: Generally faster than `Map.get()` for large datasets, as it only needs to iterate through the array once.
	+ Cons: May be slower for small arrays or when the condition is not met, leading to a longer iteration.
* `Map.get()` :
	+ Pros: Fast lookups in maps are typically optimized by the browser, making it suitable for small to medium-sized datasets.
	+ Cons: May perform poorly on large datasets, as map lookups require iterating through the keys (i.e., array elements).

**Library and Purpose**

In this benchmark, the `arrayToMap()` function is used to convert arrays to maps. The purpose of this conversion is not explicitly stated in the JSON data, but it's likely being tested to see if it affects performance.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax mentioned in the provided code. However, the use of `getRandomElement()` and `getRandomInt()` functions suggests that the test cases are designed to simulate random data generation.

**Other Alternatives**

If you're looking for alternative approaches, consider the following:

* Using `Array.prototype.findIndex()` instead of `Array.find()`, as it returns -1 if no element is found.
* Utilizing a `Set` data structure for lookups, as it provides fast membership testing and intersection operations.

Keep in mind that these alternatives may not be directly applicable to this specific benchmark, but they can be useful in other performance optimization scenarios.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Windows

View result in a separate tab

Test name	Executions per second
Array.find, 10 000 elements	2557043.5 Ops/sec
Map.get, 10 000 elements	3385031.8 Ops/sec
Array.find, 1 000 000 elements	48306.5 Ops/sec
Map.get, 1 000 000 elements	3546131.0 Ops/sec

Related benchmarks:

SJ - Array.find vs. Map.get (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

Created: 4 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

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):