Benchmark: String Array: Includes vs regex test vs indexOf

Script Preparation code:

var targetString = 'could'

var stringArray = [
    "Hopes",
    "and",
    "dreams",
    "were",
    "dashed",
    "that",
    "day.",
    "It",
    "should",
    "have",
    "been",
    "expected,",
    "but",
    "it",
    "still",
    "came",
    "as",
    "a",
    "shock.",
    "The",
    "warning",
    "signs",
    "had",
    "been",
    "ignored",
    "in",
    "favor",
    "of",
    "the",
    "possibility,",
    "however",
    "remote,",
    "that",
    "it",
    "could",
    "actually",
    "happen.",
    "That",
    "possibility",
    "had",
    "grown",
    "from",
    "hope",
    "to",
    "an",
    "undeniable",
    "belief",
    "it",
    "must",
    "be",
    "destiny.",
    "That",
    "was",
    "until",
    "it",
    "wasn't",
    "and",
    "the",
    "hopes",
    "and",
    "dreams",
    "came",
    "crashing",
    "down."
]

Tests:

Array.prototype.includes()
stringArray.includes(targetString)
RegExp.prototype.test()
new RegExp(stringArray.join('|')).test(targetString)
Array.prototype.indexOf()
stringArray.indexOf(targetString)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.includes()
RegExp.prototype.test()
Array.prototype.indexOf()

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
Array.prototype.includes()	7989194.0 Ops/sec
RegExp.prototype.test()	199674.6 Ops/sec
Array.prototype.indexOf()	7271719.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases to understand what's being tested.

**Benchmark Definition**

The benchmark is testing three different approaches to check if a string exists in an array:

1. `stringArray.includes(targetString)`
2. `new RegExp(stringArray.join('|')).test(targetString)`
3. `stringArray.indexOf(targetString)`

These tests aim to compare the performance of using `includes()`, regular expressions (`RegExp`), and `indexOf()` methods on arrays.

**Options Compared**

The benchmark is comparing:

* **Inclusive vs Regex test**: Using `includes()` vs using a regular expression (`RegExp`) to check if a string exists in an array.
* **Regex vs indexOf**: Using a regular expression (`RegExp`) vs the `indexOf()` method to achieve similar results.

**Pros and Cons of Each Approach**

1. **`includes()` Method**:
	* Pros: Simple, readable, and widely supported by most browsers.
	* Cons: Can be slower for large arrays or specific use cases due to its implementation details.
2. **Regular Expressions (`RegExp`)**:
	* Pros: Flexible, powerful, and suitable for more complex string matching scenarios.
	* Cons: Steeper learning curve, potentially slower than other approaches, and may have security implications if not used carefully.
3. **`indexOf()` Method**:
	* Pros: Similar to `includes()`, but can be faster due to its optimized implementation in some browsers.
	* Cons: May return -1 for non-existent elements, which can be misleading depending on the use case.

**Library Used**

None explicitly mentioned, but it's likely that the test cases are using built-in JavaScript functions (`includes()`, `indexOf()`) and regular expressions (defined with the `new RegExp()` constructor).

**Special JS Features or Syntax**

* The `includes()` method is a relatively new addition to the JavaScript standard library (added in ECMAScript 2019) and is designed for simplicity and readability.
* Regular expressions (`RegExp`) are an established feature in JavaScript, providing a powerful way to match patterns in strings.

**Other Considerations**

When choosing between these approaches, consider the specific use case:

* For simple string existence checks, `includes()` might be the most suitable choice due to its readability and performance in most browsers.
* For more complex string matching or when dealing with edge cases, regular expressions (`RegExp`) are often a better fit.

Keep in mind that benchmark results may vary depending on factors like browser versions, device hardware, and specific array contents.

**Alternative Approaches**

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

* Using `some()` method: `stringArray.some((element) => element === targetString)`
* Using a custom function with a loop or recursion
* Utilizing libraries like Lodash or Underscore.js, which provide various utility functions for working with arrays.

Related benchmarks:

String Array: Includes vs regex test vs indexOf (version: 0)

Comparing performance of: Array.prototype.includes() vs RegExp.prototype.test() vs Array.prototype.indexOf()

Created: 2 years ago by: Guest

Jump to the latest result

Array.prototype.includes()

RegExp.prototype.test()

Array.prototype.indexOf()

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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