Benchmark: set.has vs. array.includes vs array.indexOf (string values)

Script Preparation code:

var a = [
  'height',
  'width',
  'maxHeight',
  'maxWidth',
  'maxHeight',
  'minWidth',
  'color',
  'bg',
  'backgroundColor',
  'opacity',
  'm',
  'mt',
  'mb',
  'mr',
  'mr',
  'mx',
  'my',
  'p',
  'pt',
  'pb',
  'pr',
  'pl',
  'px',
  'py',
  'border',
  'boxShadow',
  'flex',
  'verticalAlign',
  'textAlign',
  'overflow',
  'display',
  'cursor'
];
var b = new Set(a)

Tests:

includes
return a.includes('mx')
lookup
return b.has('mx')
indexof
return a.indexOf('mx') >= 0

Historical Performance Data aggregated from 97 community runs

Desktop Results:

Chrome 76 runs

lookup

28.1M/s

includes

27.1M/s

indexof

17.6M/s

Fastest: lookup (1.6x faster)

View exact numbers

✓ lookup: 28,113,452 ops/sec
• includes: 27,094,768 ops/sec
• indexof: 17,640,060 ops/sec

Firefox 11 runs

lookup

1503.2M/s

indexof

31.7M/s

includes

26.1M/s

Fastest: lookup (57.6x faster)

View exact numbers

✓ lookup: 1,503,163,008 ops/sec
• indexof: 31,744,506 ops/sec
• includes: 26,090,802 ops/sec

Mobile Results:

Chrome 10 runs

lookup

15.4M/s

indexof

13.4M/s

includes

10.5M/s

Fastest: lookup (1.5x faster)

View exact numbers

✓ lookup: 15,421,944 ops/sec
• indexof: 13,380,165 ops/sec
• includes: 10,504,388 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
lookup
indexof

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 148 on Windows

View result in a separate tab

lookup

234.6M/s

indexof

58.3M/s

includes

54.5M/s

View exact numbers

Test name	Executions per second
✓ lookup	234,649,360 Ops/sec
indexof	58,273,688 Ops/sec
includes	54,454,748 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**Benchmark Overview**

The benchmark compares the performance of three different methods for checking if a value exists within an array or set:

1. `array.includes(value)`: checks if a value is present in the array using the `includes()` method.
2. `set.has(value)`: checks if a value is present in the Set data structure using the `has()` method.
3. `array.indexOf(value)` (or, equivalently, `value >= 0 && array.includes(value)`) : checks if an index exists for a value in the array by attempting to find its position.

**Options Compared**

The three options are compared:

* **`array.includes(value)`**: uses the `includes()` method of arrays.
	+ Pros: simple and intuitive, widely supported across browsers.
	+ Cons: can be slower than other methods for large datasets due to the need to traverse the array from start to end.
* **`set.has(value)`**: uses the `has()` method of Sets.
	+ Pros: fast and efficient, especially for large datasets since it only needs to check if the value is present in the set.
	+ Cons: requires a Set data structure, which may not be available or supported by all browsers.
* **`array.indexOf(value)`**: uses the `indexOf()` method of arrays (or an equivalent implementation using `includes() && value >= 0`).
	+ Pros: simple and efficient for large datasets, as it only needs to find the index of the value if present.
	+ Cons: slower than `set.has()` since it requires traversing the array from start to end.

**Library Used**

The benchmark uses JavaScript's built-in Set data structure. The Set data structure is a collection of unique values that can be used for efficient membership testing (i.e., checking if a value exists within the set).

**Special JS Features or Syntax**

This benchmark does not use any special JavaScript features or syntax beyond what's required to implement the three options being compared.

**Other Alternatives**

Other alternatives for these methods include:

* **Using `includes()` with an array filter`: `array.filter(value => value === target).length > 0`
	+ Pros: can be faster than `indexOf()` since it doesn't require traversing the entire array.
	+ Cons: slower than `set.has()` due to the need to create a new filtered array.
* **Using `in` operator**: `target in array || set.has(target)`
	+ Pros: simple and efficient for checking membership, but may not be supported by older browsers or versions of JavaScript.

It's worth noting that the choice of method will depend on the specific requirements of your use case, such as the size of the dataset, the available resources (e.g., CPU power, memory), and the trade-offs between simplicity, performance, and code readability.

set.has vs. array.includes vs array.indexOf (string values) (version: 0) Benchmark.js

Comparing performance of: `includes vs lookup vs indexof`

Created: 6 years ago by: Guest

Go to the latest result

includes

lookup

indexof

Historical Performance Data aggregated from 97 community runs

Desktop Results:

Chrome 76 runs

Firefox 11 runs

Mobile Results:

Chrome 10 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

set.has vs. array.includes vs array.indexOf (string values) (version: 0) Benchmark.js

Comparing performance of: includes vs lookup vs indexof

Created: 6 years ago by: Guest

Go to the latest result

includes

lookup

indexof

Historical Performance Data aggregated from 97 community runs

Desktop Results:

Chrome 76 runs

Firefox 11 runs

Mobile Results:

Chrome 10 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `includes vs lookup vs indexof`