Benchmark: Array.find vs. Map.get 2

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(3);
array_large = getArray(10);

map_small = arrayToMap(array_small);
map_large = arrayToMap(array_large);

Tests:

Array.find, 3elements
const target = getRandomInt(2); array_small.find(el => el.id === target);
Map.get, 3 elements
const target = getRandomInt(2); map_small.get(target);
Array.find, 10 elements
const target = getRandomInt(9); array_large.find(el => el.id === target);
Map.get, 10 elements
const target = getRandomInt(9); map_large.get(target)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.find, 3elements
Map.get, 3 elements
Array.find, 10 elements
Map.get, 10 elements

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of `Array.find()` and `Map.get()` methods in JavaScript. The tests are designed to measure the execution speed of these methods on different array sizes (small vs. large) with/without conversion from an array to a map.

**Options Being Compared**

Two main options are being compared:

1. **Array.find()**: This method searches for the first element in an array that satisfies the provided condition.
2. **Map.get()**: This method retrieves the value associated with a given key from a map (dictionary).

**Pros and Cons of Each Approach**

**Array.find():**

Pros:

* More intuitive and readable code
* Can be used on any type of collection, not just arrays

Cons:

* May have to iterate over the entire array if no match is found
* Can be slower than Map.get() for large datasets

**Map.get():**

Pros:

* Typically faster than Array.find() for large datasets due to its optimized internal data structure (hash tables)
* Can reduce memory usage by avoiding unnecessary iterations

Cons:

* Requires an additional data structure (map) to store the data
* May be less intuitive and readable code, especially for those without prior experience with maps

**Additional Considerations**

The benchmark also considers the conversion from an array to a map using `arrayToMap()`. This adds another variable to the test results, as it may impact performance. However, in most cases, this conversion would not significantly affect the overall performance of either method.

**Library and Syntax Used in Test Cases**

In these tests, no additional libraries are used beyond JavaScript's built-in `Array` and `Map` objects. The syntax for `Array.find()` and `Map.get()` is straightforward and follows standard JavaScript conventions.

**Special JS Features or Syntax (None)**

There are no special JavaScript features or syntax being used in this benchmark that would affect the results.

**Alternative Approaches**

If you're interested in exploring alternative approaches, here are a few options:

* **Using iterators**: Instead of using `Array.find()` and `Map.get()`, you could use iterators (e.g., `for...of` loops) to iterate over the array or map. This approach can provide more control over iteration but may not be as efficient.
* **Custom data structures**: You could create custom data structures (e.g., linked lists, binary search trees) to optimize search and retrieval operations. However, this would likely require significant changes to your codebase.

In summary, the benchmark compares the performance of `Array.find()` and `Map.get()` methods in JavaScript, considering different array sizes and conversions from arrays to maps. While there are pros and cons to each approach, `Map.get()` is typically faster for large datasets due to its optimized internal data structure.

Latest run results:

Run details: (Test run date: 13 days ago)

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

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.find, 3elements	8910955.0 Ops/sec
Map.get, 3 elements	9938924.0 Ops/sec
Array.find, 10 elements	8716587.0 Ops/sec
Map.get, 10 elements	10712765.0 Ops/sec

Related benchmarks:

Array.find vs. Map.get 2 (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, 3elements vs Map.get, 3 elements vs Array.find, 10 elements vs Map.get, 10 elements

Created: 3 months ago by: Guest

Jump to the latest result

Array.find, 3elements

Map.get, 3 elements

Array.find, 10 elements

Map.get, 10 elements

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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