Benchmark: .includes() vs .test() vs .match() vs .indexOf()

Script Preparation code:

var url='https://www.google.com/matchthis/other/args'

Tests:

text.includes()
url.includes('matchthis')
regex.test()
/matchthis/.test(url)
string.match()
url.match(/matchthis/)
string.indexOf()
url.indexOf('matchthis') >= 0

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
text.includes()
regex.test()
string.match()
string.indexOf()

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 135 on Linux

View result in a separate tab

Test name	Executions per second
text.includes()	146918048.0 Ops/sec
regex.test()	26141508.0 Ops/sec
string.match()	17273334.0 Ops/sec
string.indexOf()	149214816.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared, and the pros and cons of each approach.

**Benchmark Definition**

The benchmark compares four different intra-string matching styles: `.includes()`, `.test()`, `.match()`, and `.indexOf()`.

**Options Compared**

* `text.includes()`: This is a simple string method that checks if a specified value (in this case, "matchthis") exists in the original URL.
* `regex.test(url)`: This uses regular expressions to search for the pattern "matchthis" in the URL. The `test()` method returns `true` if the pattern is found anywhere in the string.
* `string.match(/matchthis/)`: Similar to `regex.test()`, this uses a regular expression to find the pattern "matchthis" in the URL. However, it returns an array of all matches instead of just a boolean result.
* `string.indexOf('matchthis') >= 0`: This is another simple string method that checks if the substring "matchthis" exists in the original URL.

**Pros and Cons**

* **`.includes()`**: Pros - Simple, easy to understand, and widely supported. Cons - Can be slow for large strings or complex patterns.
* **`regex.test(url)`**: Pros - Powerful and flexible regular expression engine. Cons - Can be slow, especially for complex patterns or very long strings. Requires knowledge of regular expressions.
* **`string.match(/matchthis/)`**: Pros - Returns an array of all matches, can be useful for more complex searches. Cons - Returns multiple values, which might not be what you want. Can be slower than `.includes()` or `.indexOf()`.
* **`string.indexOf('matchthis') >= 0`**: Pros - Simple and fast, but may not work as expected if "matchthis" is part of a larger string. Cons - Not suitable for complex patterns.

**Library and Purpose**

None mentioned in the provided benchmark definition.

**Special JS Feature or Syntax**

* None explicitly mentioned. However, `regex.test(url)` uses regular expressions, which are a powerful but also complex feature of JavaScript.

**Other Considerations**

The benchmark is focused on comparing these four string matching styles, but it's worth noting that:

* In modern JavaScript engines (ECMAScript 2015+), `.includes()` and `.indexOf()` are often optimized to be more efficient than `string.match()`.
* For complex patterns or large strings, using a dedicated regular expression engine like `regex.test()` might be the best choice.
* For simple searches where speed is not a concern, `.includes()` or `.indexOf()` might be sufficient.

**Alternatives**

Other alternatives for string matching in JavaScript include:

* Using a library like `lodash` which provides various string methods and utilities.
* Implementing custom string matching logic using bitwise operations or other techniques.
* Using a different data structure, such as an array of substrings, to improve search performance.

Keep in mind that the choice of method depends on the specific requirements of your use case.

Related benchmarks:

.includes() vs .test() vs .match() vs .indexOf() (version: 0)

Compare different intra-string matching styles

Comparing performance of: text.includes() vs regex.test() vs string.match() vs string.indexOf()

Created: 3 years ago by: Registered User

Jump to the latest result

text.includes()

regex.test()

string.match()

string.indexOf()

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