Benchmark: .includes() vs .test() vs .match() vs .toLowerCase().indexOf() with non-alpha 1

Script Preparation code:

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

Tests:

text.includes()
url.includes('matchthis:(&this')
regex.test()
/matchthis\:\(\&this/.test(url)
string.match()
url.match(/matchthis\:\(\&this/)
string.indexOf()
url.indexOf('matchthis:(&this') >= 0
string.toLowerCase().indexOf()
url.toLowerCase().indexOf('matchthis:(&this') >= 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()
string.toLowerCase().indexOf()

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 116 on Windows

View result in a separate tab

Test name	Executions per second
text.includes()	19354548.0 Ops/sec
regex.test()	11003949.0 Ops/sec
string.match()	6793994.5 Ops/sec
string.indexOf()	12786649.0 Ops/sec
string.toLowerCase().indexOf()	16315572.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided JSON represents a benchmark test that compares different methods for searching for a specific string within another string. The benchmark is designed to measure the performance of various approaches in different browsers and devices.

**Methods Being Compared**

The following methods are being compared:

1. `text.includes()`: This method checks if the specified string (`"matchthis:(&this"`) exists within the provided URL (`url`).
2. `regex.test(url)`: This method uses a regular expression to search for the specified string in the URL.
3. `string.match(/matchthis\\:\\(\\&this/)/)`: This method uses a regular expression to search for the specified string in the URL.
4. `string.indexOf('matchthis:(&this') >= 0`: This method searches for the specified string within the provided URL using the `indexOf()` method and checks if the result is greater than or equal to 0.

**Pros and Cons of Each Approach**

1. **text.includes()**: This method is likely to be the fastest, as it uses a simple substring search algorithm. However, it may not be suitable for cases where the search string is complex or contains special characters.
2. **regex.test(url)`: This method uses regular expressions to perform the search, which can be slower than other methods due to the overhead of compiling and executing the regex pattern. However, it provides a flexible way to match complex patterns.
3. **string.match(/matchthis\\:\\(\\&this/)/)**: Similar to `regex.test()`, this method uses regular expressions but with a different syntax. It's likely to be slower than `text.includes()` due to the overhead of compiling and executing the regex pattern.
4. **string.indexOf('matchthis:(&this') >= 0**: This method is similar to `text.includes()`, but it returns an integer result instead of a boolean value. It's likely to be faster than the other methods that return a boolean value, as it avoids the overhead of comparing a boolean value to true or false.

**Library Used**

None of the provided methods use any external libraries or frameworks, making them suitable for most JavaScript applications.

**Special JS Feature/Syntax**

No special JS features or syntax are used in this benchmark. All methods comply with standard JavaScript syntax and semantics.

**Other Alternatives**

Some alternative approaches that could be considered for searching strings within other strings include:

* Using the `String.prototype.indexOf()` method, which is similar to `string.indexOf()`.
* Using a dedicated string search library like `StringSearch` or `Regexp`.
* Implementing a custom substring search algorithm using bitwise operations and loop optimization.

It's worth noting that the performance of these alternative approaches may vary depending on the specific use case and requirements.

Related benchmarks:

.includes() vs .test() vs .match() vs .toLowerCase().indexOf() with non-alpha 1 (version: 0)

Compare different intra-string matching styles

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

Created: one year ago by: Guest

Jump to the latest result

text.includes()

regex.test()

string.match()

string.indexOf()

string.toLowerCase().indexOf()

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