Benchmark: indexOf vs map.get vs obj[key]

Script Preparation code:

const array = [];
for (let i=0; i<1000; ++i) {
  	array.push('00' + i);
}

let entries = array.map((value, index) => [value, index])
let map = new Map(structuredClone(entries));

var obj = Object.fromEntries(structuredClone(entries));

function usingArray(value) {
	return array.indexOf(value);
}


function usingObject(value) {
   return obj[value] ?? -1;
}

function usingMap(value) {
    return map.get(value) ?? -1;
}

Tests:

indexOf
for (var i=0; i<100; ++i) { usingArray('404'); }
obj
for (var i=0; i<100; ++i) { usingObject('404'); }
map
for (var i=0; i<100; ++i) { usingMap('404'); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf
obj
map

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.

Let's dive into the world of MeasureThat.net and understand what's being tested in this benchmark.

**Benchmark Definition**

The benchmark definition is a JSON object that describes three different test cases:

1. `indexOf`: This test case uses the `array.indexOf()` method to search for a specific value in an array.
2. `obj`: This test case uses the dot notation (`obj[key]`) to access a property in an object. In this case, it's searching for a key that might not exist.
3. `map`: This test case uses the `Map.get()` method to retrieve a value from a map (a data structure that stores key-value pairs).

**Options Compared**

The benchmark is comparing the performance of these three approaches:

* `indexOf` vs `array.indexOf()`
* `obj` vs dot notation (`obj[key]`)
* `map` vs `Map.get()`

**Pros and Cons of Each Approach**

Here's a brief overview of each approach:

1. **`indexOf` vs `array.indexOf()`**:
	* `indexOf`: This method returns the index of the first occurrence of the specified value in the array. If not found, it returns `-1`.
	* `array.indexOf()`: Similar to `indexOf`, but can be used with other data structures like arrays and sets.
	Pros: Efficient for large datasets, easy to use.
	Cons: Returns an index, which might be useful only when iterating over a list of indices.
2. **`obj` vs dot notation (`obj[key]`)**:
	* `obj`: This method creates a new object from the provided key-value pairs and returns it.
	Pros: Creates a new object with a specific structure, easy to use.
	Cons: Returns an entire object, which can be unnecessary for just searching for a value.
3. **`map` vs `Map.get()`**:
	* `map`: Similar to `obj`, but creates a map instead of an object.
	Pros: Efficient for large datasets, easy to use.
	Cons: Returns an entire map if the key is not found.

**Library and Purpose**

The benchmark uses three libraries:

1. **structuredClone**: This function clones the provided data structure (e.g., array, object, map) to create a new copy. It's used to populate the `map` and `obj` test cases.
2. None (no other libraries are mentioned).

**Special JS Features or Syntax**

There are no special JavaScript features or syntax mentioned in this benchmark.

Now that we've covered the basics, let's talk about some alternative approaches:

* **Using a Set**: Instead of using an array for the `indexOf` test case, you could use a set, which would be even faster for large datasets.
* **Using a Sparse Array**: If you know that the values in your dataset will always be non-negative integers, you could use a sparse array (a compact array with only non-zero elements) instead of a regular array.
* **Using a Different Data Structure**: Depending on the specific requirements of your benchmark, you might consider using other data structures like a trie or a suffix tree.

Keep in mind that these alternatives are not mentioned in the benchmark definition and would require additional changes to the test code.

Related benchmarks:

indexOf vs map.get vs obj[key] (version: 0)

Comparing performance of: indexOf vs obj vs map

Created: 3 years ago by: Guest

Jump to the latest result

indexOf

obj

map

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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