Benchmark: test array vs map lookup 3

Script Preparation code:

// Generate an array with 100 objects
var rawData = [];
for (let i = 0; i < 5001; i++) {
  rawData.push({
    cost_per: Math.random() * 100,
    network: `network${i}`,
    metric: {
      name: `metric${i}`,
      description: `Description ${i}`,
    }
  });
}

// Using a Map for indexing
var transformedDataMap = new Map();

for (const entry of rawData) {
  const key = `${entry.network}_${entry.metric.name}`
  transformedDataMap.set(key, entry.cost_per);
}

Tests:

Test using Map for indexing (5000 iterations)
const iterations = 5000; for (let i = 0; i < iterations; i++) { const mapLookupKey = `network${i}_metric${i}` const mapResult = transformedDataMap.get(mapLookupKey); }
Test using Array.prototype.find (5000 iterations)
const iterations = 5000; const arrayStartTime = new Date().getTime(); for (let i = 0; i < iterations; i++) { const arrayLookupKey = { network: 'network' + i, metricName: 'metric' + i, }; const arrayResult = rawData.find((entry) => { return ( entry.network === arrayLookupKey.network && entry.metric.name === arrayLookupKey.metricName ); }); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Test using Map for indexing (5000 iterations)
Test using Array.prototype.find (5000 iterations)

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 is being tested, compared options, their pros and cons, and other considerations.

**Benchmark Definition**

The benchmark measures the performance difference between two approaches:

1. **Using a Map for indexing**: The code creates an array with 5001 objects and then iterates over it to create a `Map` object where each key is a combination of the `network` and `metric.name` properties. Then, it uses the `Map` to look up values based on specific keys.
2. **Using Array.prototype.find**: The code creates an array with 5001 objects and then iterates over it to find a specific object that matches certain conditions.

**Options Compared**

The two options being compared are:

* **Map for indexing**
	+ Pros:
		- Fast lookup times (O(1) on average)
		- Can handle large datasets
	+ Cons:
		- Requires more memory to store the `Map` object
		- Might require additional code to create and manage the keys
* **Array.prototype.find**: 
	+ Pros:
		- Lightweight and easy to implement
		- Supports iteration and filtering out of the box
	+ Cons:
		- Has a higher overhead due to the need for iterating over the array
		- May have slower lookup times compared to Map (O(n) on average)

**Library Used**

In this benchmark, `Map` is used as a library. A `Map` in JavaScript is an object that stores key-value pairs, where each key is unique and maps to a specific value.

**Other Considerations**

* **JavaScript version**: The benchmark does not specify the exact JavaScript version being used. However, since Chrome 117 is mentioned, it's likely that the benchmark uses a relatively modern version of JavaScript.
* **Device and browser**: The benchmark results are reported for a Chrome 117 browser on Linux desktop platforms. This suggests that the benchmark might be optimized for this specific device and browser combination.

**Alternatives**

Other alternatives to these two options could include:

* Using `Object.keys()` and `Array.prototype.forEach` to iterate over an array
* Using `JSON.stringify()` and `JSON.parse()` to convert objects to strings and back to objects
* Using other data structures, such as a hash table or a trie

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36

Browser/OS: Chrome 117 on Linux

View result in a separate tab

Test name	Executions per second
Test using Map for indexing (5000 iterations)	4544.4 Ops/sec
Test using Array.prototype.find (5000 iterations)	21.8 Ops/sec

Related benchmarks:

test array vs map lookup 3 (version: 0)

asd

Comparing performance of: Test using Map for indexing (5000 iterations) vs Test using Array.prototype.find (5000 iterations)

Created: one year ago by: Guest

Jump to the latest result

Test using Map for indexing (5000 iterations)

Test using Array.prototype.find (5000 iterations)

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):