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

Script Preparation code:

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

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 OPR/93.0.0.0

Browser/OS: Opera 93 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
text.includes()	11854962.0 Ops/sec
text.test()	7758397.5 Ops/sec
text.match()	6248231.0 Ops/sec
text.indexOf()	12214761.0 Ops/sec
text.search()	2946570.0 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 data and explain what's being tested, the options compared, their pros and cons, and other considerations.

**Benchmark Definition**

The benchmark is comparing five different string search methods:

1. `includes()`
2. `test()`
3. `match()`
4. `indexOf()`
5. `search()`

These methods are used to find a specified substring within a given string.

**Test Cases**

Each test case has two parts: a "Benchmark Definition" and a "Test Name". The Benchmark Definition specifies the search condition, while the Test Name provides additional context for each test.

Here's a brief explanation of each test case:

1. `text.includes('matchthis')`: Tests if the string `'matchthis'` is present anywhere in the original URL.
2. `/matchthis/.test(url)`: Tests if the regular expression `/matchthis/` matches anywhere in the URL (note: this uses a forward slash to delimit the regex pattern).
3. `url.match(/matchthis/)`: Tests if the string `'matchthis'` is found as a whole word within the URL.
4. `text.indexOf('matchthis') >= 0`: Tests if the index of the first occurrence of `'matchthis'` in the original URL is greater than or equal to 0 (i.e., if it's present).
5. `url.search('matchthis') >= 0`: Tests if the search query string for the URL contains `'matchthis'`.

**Libraries and Special JS Features**

In this benchmark, no external libraries are used beyond standard JavaScript functionality.

However, note that:

* In test case 2, `/matchthis/.test(url)` uses a forward slash to delimit the regular expression pattern. This is a non-standard way of escaping special characters in regex patterns.
* The `includes()` method is supported by modern browsers starting from around 2015 (Chrome 45, Firefox 40). However, older browsers like Internet Explorer may not support it.

**Pros and Cons**

Here's a brief pros and cons analysis for each test case:

1. `text.includes('matchthis')`:
	* Pros: Simple to implement, widely supported.
	* Cons: May be slower than other methods due to the use of string iteration.
2. `/matchthis/.test(url)`:
	* Pros: Fast, concise way to check for substring presence using regex.
	* Cons: Less readable, requires knowledge of forward slash escaping for special characters.
3. `url.match(/matchthis/)`:
	* Pros: Fast, efficient way to find whole word occurrences.
	* Cons: May be slower than other methods due to the use of regular expressions.
4. `text.indexOf('matchthis') >= 0`:
	* Pros: Simple to implement, widely supported.
	* Cons: Returns an index value (or -1 if not found), which may require additional processing.
5. `url.search('matchthis') >= 0`:
	* Pros: Fast, concise way to check for search query string presence.
	* Cons: Less readable, requires knowledge of the `search()` method's behavior.

**Alternatives**

If you're looking for alternatives or variations on this benchmark, consider:

* Using a different language or implementation (e.g., Python, Java) to compare performance across languages.
* Adding more test cases to cover additional edge cases or scenarios (e.g., case-insensitive searches).
* Including other string processing methods, such as `startsWith()` or `endsWith()`, for comparison.

Keep in mind that the specific choices of test cases and methods will depend on your testing goals and requirements.

Related benchmarks:

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

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

Created: 2 years ago by: Guest

Jump to the latest result

text.includes()

text.test()

text.match()

text.indexOf()

text.search()

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