Benchmark: set.has vs. array.includes vs array.indexOf (for 10n, 100n and 10000n)

Script Preparation code:

var arr10 = [...Array(10).keys()];
var set10 = new Set(arr10);

var arr100 = [...Array(100).keys()];
var set100 = new Set(arr100)

var arr10000 = [...Array(10000).keys()];
var set10000 = new Set(arr10000)

Tests:

includes 10n
return arr10.includes(9);
lookup 10n
return set10.has(9);
indexOf 10n
return arr10.indexOf(9) >= 0;
includes 100n
return arr100.includes(99);
lookup 100n
return set100.has(99);
indexOf 100n
return arr100.indexOf(99) >= 0;
includes 10000n
return arr10000.includes(9999);
lookup 10000n
return set10000.has(9999);
indexOf 10000n
return arr10000.indexOf(9999) >= 0;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes 10n
lookup 10n
indexOf 10n
includes 100n
lookup 100n
indexOf 100n
includes 10000n
lookup 10000n
indexOf 10000n

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15

Browser/OS: Safari 14 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
includes 10n	8802015.0 Ops/sec
lookup 10n	7607178.0 Ops/sec
indexOf 10n	7712487.0 Ops/sec
includes 100n	4348148.0 Ops/sec
lookup 100n	7154253.0 Ops/sec
indexOf 100n	2449025.2 Ops/sec
includes 10000n	59668.6 Ops/sec
lookup 10000n	10336135.0 Ops/sec
indexOf 10000n	55807.6 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is tested?**

The benchmark tests three different ways to check if an element exists in an array or set:

1. `array.includes()`: checks if an element is present in the array using the `includes()` method.
2. `set.has()`: checks if an element is present in the set using the `has()` method.
3. `array.indexOf()`: checks if an element is present in the array by finding its index using the `indexOf()` method.

**Options compared**

The benchmark compares these three options across different sizes of arrays (10, 100, and 10,000 elements) for both arrays and sets.

**Pros and cons of each approach:**

1. **`array.includes()`**:
	* Pros: simple to use, efficient for large arrays.
	* Cons: can be slow for very large arrays due to the need to scan the entire array, and may have a higher overhead compared to native `has()` methods.
2. **`set.has()`**:
	* Pros: very fast, especially for large sets, since sets are implemented as hash tables and can look up elements in constant time.
	* Cons: requires more memory than arrays and may not be suitable for scenarios where memory is limited.
3. **`array.indexOf()`**:
	* Pros: simple to use, efficient for finding the first occurrence of an element.
	* Cons: can be slow if the element is not found (returns -1), and may have a higher overhead compared to native `has()` methods.

**Other considerations**

When working with large datasets or performance-critical code, it's essential to consider the trade-offs between these approaches. For example:

* If you need to perform frequent lookups in an array or set, using native `set.has()` might be the best option.
* If you're dealing with a large array and need to find the first occurrence of an element, using `array.indexOf()` might be sufficient.

**Benchmarks**

The provided benchmark results show that `set.has()` is consistently the fastest option for finding elements in sets, while `array.includes()` is generally slower than native `has()` methods. However, `array.indexOf()` can be slow if the element is not found or if the array is very large.

Keep in mind that these results are specific to Safari 14 on a Mac, and you may see different performance characteristics on other browsers or platforms.

In summary, when working with JavaScript arrays and sets, it's essential to choose the right approach based on your specific use case, considering factors such as performance, memory constraints, and simplicity.

Related benchmarks:

set.has vs. array.includes vs array.indexOf (for 10n, 100n and 10000n) (version: 1)

Comparing performance of: includes 10n vs lookup 10n vs indexOf 10n vs includes 100n vs lookup 100n vs indexOf 100n vs includes 10000n vs lookup 10000n vs indexOf 10000n

Created: 3 years ago by: Registered User

Jump to the latest result

includes 10n

lookup 10n

indexOf 10n

includes 100n

lookup 100n

indexOf 100n

includes 10000n

lookup 10000n

indexOf 10000n

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):