Benchmark: Array.includes() vs. manual compare 2

Script Preparation code:

var arr = ['cat', 'dog', 'duck'];
var search1 = new Date().toString();
var search2 = new Date().toString();

Tests:

includes()
var found = arr.includes(search1); var notFound = arr.includes(search2);
manual comparison
var found = search1 === 'cat' || search1 === 'dog' || search1 === 'duck'; var notFound = search2 === 'cat' || search2 === 'dog' || search2 === 'duck';

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes()
manual comparison

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/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36

Browser/OS: Chrome 90 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
includes()	3780136.2 Ops/sec
manual comparison	2747387.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark data and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The benchmark measures the performance of two approaches to check if an element exists in an array:

1. Using the `Array.includes()` method
2. Manual comparison using a series of `===` checks

**Options Compared**

* `Array.includes()` vs. manual comparison (using `===` checks)

**Pros and Cons**

### Array.includes()

Pros:

* Concise and readable code
* Easy to understand and maintain
* Optimized for performance by the browser's engine

Cons:

* May have a higher overhead due to the browser's engine processing the includes() method
* Can be slower than manual comparison in certain cases (e.g., when the array is large)

### Manual Comparison

Pros:

* Directly compares the search value with each element in the array, avoiding any potential overhead of the `includes()` method
* May be faster for small arrays or when exact matches are required

Cons:

* Code can become complex and harder to read as the number of elements increases
* More prone to errors due to typos or incorrect logic

**Library Used**

In this benchmark, no specific JavaScript library is used.

**Special JS Feature/Syntax**

None mentioned in the provided code.

**Other Alternatives**

If you need to check if an element exists in an array, other alternatives exist:

1. `Array.prototype.indexOf()`: Similar to `includes()` but returns the index of the first match instead of a boolean value.
2. `Set` data structure: You can use a Set to store unique values and then check for existence using the `has()` method.

However, these alternatives may not be as straightforward or readable as the `Array.includes()` approach.

**Benchmark Preparation Code**

The preparation code creates an array `arr` with three elements (`'cat'`, `'dog'`, and `'duck'`) and two timestamps `search1` and `search2`. These timestamps are used to simulate searching for specific values in the array, simulating real-world usage scenarios.

In summary, this benchmark allows users to compare the performance of two approaches: using the `Array.includes()` method versus manual comparison. The results provide insight into which approach is faster and more efficient in different browsers and devices.

Related benchmarks:

Array.includes() vs. manual compare 2 (version: 0)

Comparing performance of: includes() vs manual comparison

Created: 3 years ago by: Guest

Jump to the latest result

includes()

manual comparison

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