Benchmark: indexOf vs map on small arrays

Script Preparation code:

var array = [];
for (var i=0; i<300; ++i) {
  	array.push('00' + i);
}

function hasWithIndexOf(needle) {
	return array.indexOf(needle) !== -1;
}

var map = {};
array.forEach(item => map[item] = true);

function hasWithMap(needle) {
	return needle in map;
}

Tests:

indexOf
for (var i=0; i<5; ++i) { hasWithIndexOf('404'); }
map
for (var i=0; i<5; ++i) { hasWithMap('404'); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf
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 break down the provided benchmark and its options.

**Benchmark Overview**

The benchmark compares the performance of two approaches: `indexOf` and `map`. The goal is to find the fastest way to check if an element exists in a small array (`array`).

**Options Compared**

There are two test cases:

1. **`indexOf`**: Uses the `Array.prototype.indexOf()` method, which searches for the specified value (`needle`) in the array.
2. **`map`**: Uses the `Array.prototype.forEach()` method with an object (`map`) that maps each element in the array to a truthy value (in this case, just using `true`). This approach uses the same underlying data structure as `indexOf`, but iterates over it.

**Pros and Cons of Each Approach**

1. **`indexOf`**:
	* Pros: Simple, widely supported, and efficient.
	* Cons: Can be slower for large arrays due to its linear search algorithm.
2. **`map`**:
	* Pros: Can be faster for small arrays since it only iterates over the elements once, using a constant amount of memory.
	* Cons: May not be suitable for large arrays or when memory is limited.

**Library Used**

In this benchmark, no specific libraries are used beyond the standard JavaScript `Array` methods. However, some browsers may provide additional optimizations or features that could affect the performance results (e.g., Safari's built-in optimizer).

**Special JS Feature/Syntax**

None are explicitly mentioned in the provided code snippets.

**Other Alternatives**

If you were to modify this benchmark to compare different approaches, you might consider:

* Using a larger array size to see how the algorithms scale.
* Adding additional elements to the `map` object to increase its size and test its performance.
* Exploring other data structures, such as `Set` or `WeakMap`, for element lookups.
* Investigating browser-specific optimizations or features that might affect the results.

Keep in mind that this benchmark is designed to measure the relative performance of two simple algorithms, rather than providing a comprehensive understanding of optimization techniques or advanced JavaScript topics.

Related benchmarks:

indexOf vs map on small arrays (version: 0)

indexOf vs map on small arrays

Comparing performance of: indexOf vs map

Created: 2 years ago by: Guest

Jump to the latest result

indexOf

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