Benchmark: includes vs has 20220126

Script Preparation code:

var n = 1000;
var a = [...Array(n)].map(() => Math.floor(Math.random()*n));
var b = new Set(a);
var t = a[Math.floor(n/2)];

Tests:

includes
return a.includes(t);
has
return b.has(t);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
has

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 97 on Linux

View result in a separate tab

Test name	Executions per second
includes	1909932.9 Ops/sec
has	10183305.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the JavaScript microbenchmark being tested on MeasureThat.net.

**Benchmark Overview**

The benchmark is designed to compare the performance of two different methods for checking if an element exists in an array: `includes()` and `has()`. The benchmark creates a large array of random numbers, converts it to a Set data structure, and then uses each method to search for a specific middle value in the array.

**What's being tested**

The benchmark is testing the performance difference between using the `includes()` method versus the `has()` method on arrays. Specifically, it measures how many times each method can execute per second (ExecutionsPerSecond) across different browsers and devices.

**Options compared**

The two methods being compared are:

1. **`includes()`**: This method checks if a specified value (`t`) exists in an array by iterating through the elements of the array until it finds a match.
2. **`has()`**: This method is not a built-in JavaScript method, but rather a custom implementation that uses a Set data structure to store the unique values in the array.

**Pros and Cons**

1. `includes()`: Pros:
	* Widespread support across modern browsers.
	* Simple and intuitive implementation.
Cons:
	* Can be slower than `has()` for very large arrays due to the iteration required to find the element.
2. `has()`: Pros:
	* Potential performance advantage over `includes()` for large arrays, as it uses a Set data structure to quickly check for existence.
Cons:
	* Not a built-in JavaScript method, so may require additional setup or polyfills in certain browsers.

**Library/Functionality**

The custom implementation of `has()` is likely using a Set data structure (`b`) created from the original array (`a`). When checking if an element exists using `has()`, it simply checks if the value to be searched for (`t`) is present in the set. This allows for efficient lookup times.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntax used in this benchmark beyond what's necessary to demonstrate the comparison between `includes()` and `has()` methods.

**Alternative approaches**

Other alternatives for checking if an element exists in an array could include:

1. **Using a custom implementation like `has()`, but with improved performance optimizations**.
2. **Using a data structure like a binary search tree or a hash table**, which can provide faster lookup times.
3. **Using a library or framework that provides optimized array searching methods**, such as Lodash's `_.contains()` function.

Keep in mind that the specific choice of implementation will depend on the use case, performance requirements, and personal preference.

Related benchmarks:

includes vs has 20220126 (version: 1)

Comparing performance of: includes vs has

Created: 2 years ago by: Registered User

Jump to the latest result

includes

has

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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