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

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
asdasd22
url.search(/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()
asdasd22

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Definition**

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

These methods are used to search for a specific value within a string. The main difference between them lies in how they handle regular expressions, null characters, and the overall approach to searching.

**Options Compared**

Here's a brief overview of each option:

1. `.includes()`: This method checks if a specified value is present in a string, returning `true` or `false`. It doesn't support regular expressions.
2. `.test()`: This method tests whether a string passes a test (i.e., matches a given pattern). It supports regular expressions and returns `true` or `false`.
3. `.match()`: Similar to `.test()`, but returns an array of matches if the pattern is found, or `null` otherwise.
4. `.indexOf()`: This method finds the index of the first occurrence of a specified value in a string. It doesn't support regular expressions.

**Pros and Cons**

Here's a summary of the pros and cons of each approach:

1. `.includes()`: Pros - simple, easy to use; Cons - no support for regular expressions, may be slower due to explicit looping.
2. `.test()`: Pros - supports regular expressions, concise syntax; Cons - may return `false` even if the value is present (e.g., if it's a substring), can be slower than `.includes()` for simple searches.
3. `.match()`: Pros - returns an array of matches, useful for searching multiple values; Cons - may return `null` if no match is found, can be slower due to regular expression parsing.
4. `.indexOf()`: Pros - efficient and accurate; Cons - only finds the first occurrence, doesn't support regular expressions.

**Library Usage**

None of the methods used in this benchmark require any external libraries.

**Special JS Features/Syntax**

The test cases don't use any special JavaScript features or syntax beyond what's commonly available. However, it's worth noting that `.test()` and `.match()` do utilize the `RegExp` object internally, which may be interesting for those familiar with regular expressions in JavaScript.

**Other Alternatives**

If you're looking for alternative methods to search strings, consider:

1. Using a string searching library like `string-pose` or `search-string`.
2. Implementing your own string searching algorithm using techniques like boyer-moore or Knuth-Morris-Pratt.
3. Using a JavaScript regex engine like `regex-py`.

Keep in mind that these alternatives might not provide the same level of performance as the built-in methods used in this benchmark.

In conclusion, the current benchmark compares four common string matching methods: `.includes()`, `.test()`, `.match()`, and `.indexOf()`. Each method has its pros and cons, and understanding their differences can help you choose the best approach for your specific use case.

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 16_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 16 on iOS 16.4.1

View result in a separate tab

Test name	Executions per second
text.includes()	17760508.0 Ops/sec
regex.test()	19065294.0 Ops/sec
string.match()	14024761.0 Ops/sec
string.indexOf()	18079002.0 Ops/sec
asdasd22	16774159.0 Ops/sec

Related benchmarks:

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

Compare different intra-string matching styles

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

Created: one year ago by: Guest

Jump to the latest result

text.includes()

regex.test()

string.match()

string.indexOf()

asdasd22

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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