Benchmark: Set.has() vs Array.includes() vs Array.indexOf() vs Array.lastIndexOf() vs Map.has()

Script Preparation code:

var testArray = Array(100000).fill(0).map((v, i) => i.toString(16));
var testSet = new Set(testArray);
var testMap = new Map();
testArray.forEach(v => testMap.set(v, 1));

var testCase = Array(100).fill(0).map(v => Math.floor(Math.random() * 200000).toString(16));

Tests:

Set.has()
testCase.forEach(v => testSet.has(v));
Array.includes()
testCase.forEach(v => testArray.includes(v));
Array.indexOf()
testCase.forEach(v => testArray.indexOf(v));
Array.lastIndexOf
testCase.forEach(v => testArray.lastIndexOf(v));
Map.has()
testCase.forEach(v => testMap.has(v));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set.has()
Array.includes()
Array.indexOf()
Array.lastIndexOf
Map.has()

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 125 on Windows

View result in a separate tab

Test name	Executions per second
Set.has()	265114.8 Ops/sec
Array.includes()	101.9 Ops/sec
Array.indexOf()	99.9 Ops/sec
Array.lastIndexOf	60.9 Ops/sec
Map.has()	261713.0 Ops/sec

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 JavaScript microbenchmarks.

**Benchmark Overview**

The provided benchmark, "Set.has() vs Array.includes() vs Array.indexOf() vs Array.lastIndexOf() vs Map.has()", tests the performance of five different methods to check for the presence of an element in various data structures: `Array`, `Set`, and `Map`.

**Data Structures and Methods**

1. **`Array.includes()`**: This method checks if a specified value exists in the array. It returns `true` if the value is found, and `false` otherwise.
2. **`Array.indexOf()`**: Similar to `includes()`, but it returns the index of the first occurrence of the value if found, or `-1` otherwise.
3. **`Array.lastIndexOf()`**: This method finds the index of the last occurrence of the specified value in the array. It returns the index if found, and `-1` otherwise.
4. **`Set.has()`**: A Set is a collection of unique values. The `has()` method checks if a specific value exists in the set. It returns `true` if the value is present, and `false` otherwise.
5. **`Map.has()`**: A Map is an object that stores key-value pairs. The `has()` method checks if a specified key exists in the map. It returns `true` if the key is present, and `false` otherwise.

**Options Compared**

The benchmark compares the performance of these five methods across different data structures:

* Array (`includes()`, `indexOf()`, `lastIndexOf()`)
* Set (`has()`)
* Map (`has()`)

**Pros and Cons of Each Approach**

1. **Array.includes()**:
	* Pros: Simple to implement, widely supported.
	* Cons: Can be slow for large arrays due to linear search.
2. **Array.indexOf()**:
	* Pros: Can be faster than `includes()` for finding the first occurrence of an element.
	* Cons: May not be suitable for large arrays or sparse data.
3. **Array.lastIndexOf()**:
	* Pros: Efficiently finds the last occurrence of an element, but may not work well with sparse data.
	* Cons: Can be slower than `includes()` and `indexOf()` for simple cases.
4. **Set.has()**:
	* Pros: Fast lookups due to hash-based implementation.
	* Cons: Requires more memory to store the set, and may not be suitable for very large sets.
5. **Map.has()**:
	* Pros: Similar to Set `has()` but with additional benefits like preserving key order and efficient lookups.
	* Cons: May require more memory due to storing keys, and may have slower performance due to hash-based implementation.

**Other Considerations**

When choosing between these methods, consider the following:

* **Speed**: For large datasets, `Set.has()` or `Map.has()` might be faster than array-based approaches.
* **Memory usage**: If you're working with very large datasets, consider using data structures like Sets or Maps that provide efficient lookups but require more memory.
* **Data structure characteristics**: If your data is sparse (i.e., many empty slots), `Array.lastIndexOf()` might not work well.

**Alternatives**

Other alternatives to these methods include:

* Using a binary search algorithm for finding elements in arrays, which can be faster than linear search but may require additional implementation effort.
* Implementing custom lookup algorithms using bitwise operations or other optimization techniques.
* Utilizing optimized libraries like `fast-xml` or `unicode-matcher` that provide efficient string matching and searching capabilities.

Keep in mind that the choice of method ultimately depends on the specific requirements of your project, such as performance, memory usage, and data structure characteristics.

Related benchmarks:

Set.has() vs Array.includes() vs Array.indexOf() vs Array.lastIndexOf() vs Map.has() (version: 0)

Comparing performance of: Set.has() vs Array.includes() vs Array.indexOf() vs Array.lastIndexOf vs Map.has()

Created: one year ago by: Guest

Jump to the latest result

Set.has()

Array.includes()

Array.indexOf()

Array.lastIndexOf

Map.has()

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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