Benchmark: .includes() vs .test() vs .match() vs .indexOf() (w/ -1 != and !==)

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
string.indexOf() !== -1
url.indexOf('matchthis') !== -1
string.indexOf() != -1
url.indexOf('matchthis') != -1

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.indexOf() !== -1
string.indexOf() != -1

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
text.includes()	55165836.0 Ops/sec
regex.test()	9927778.0 Ops/sec
string.match()	7203115.0 Ops/sec
string.indexOf()	57198644.0 Ops/sec
string.indexOf() !== -1	56758340.0 Ops/sec
string.indexOf() != -1	57929040.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 test cases and explain what is being tested.

**Benchmark Definition**
The benchmark compares different intra-string matching styles: `.includes()`, `.test()`, `.match()`, and `.indexOf()` (with and without `-1 !=` and `!==`).

**Options Compared**

*   `.includes()`: Returns `true` if the string contains the specified value.
*   `.test()`: Tests whether a regular expression matches any characters in the string. If the pattern returns `true` or `0`, it is considered to have matched.
*   `.match()`: Finds and returns all occurrences of a pattern in a string.
*   `.indexOf()`: Returns the index of the first occurrence of a specified value, or `-1` if not found.

**Pros and Cons**

*   **.includes():**
    *   Pros:
        *   Efficient for simple searches with a known range of possible values.
        *   Supports locale-dependent matching.
    *   Cons:
        *   May be slower than `.test()` or `.match()` for more complex patterns.
*   **.test():**
    *   Pros:
        *   Fast and efficient for regular expression matching.
        *   Can be used to test complex patterns without creating a new string.
    *   Cons:
        *   Returns `true` if the pattern matches anywhere in the string, not just at the beginning.
        *   May return incorrect results for non-regular-expression patterns.
*   **.match():**
    *   Pros:
        *   Finds all occurrences of a pattern and returns them as an array.
        *   Can be used to extract multiple values from a single string.
    *   Cons:
        *   Returns an empty array if no matches are found.
        *   May consume more resources than `.test()` or `.includes()`.
*   **.indexOf():**
    *   Pros:
        *   Efficient for searching a fixed-size range of values.
        *   Supports negative indices to access characters from the end of the string.
    *   Cons:
        *   Returns `-1` if not found, which may be confusing in some contexts.

**Special JS Feature/Syntax**

None mentioned.

**Library Usage**

No library is explicitly used in these test cases. However, some browsers (like Opera Mobile) might use internal libraries or optimizations that are not exposed by the standard JavaScript API.

**Device Platform and Browser Considerations**

The tests were run on a mobile device (Opera Mobile 74) with Android 12 operating system. The results may vary when running these tests in different environments, such as desktop browsers or other mobile devices.

**Other Alternatives**

Some alternatives to these methods could include:

*   Using `String.prototype.startsWith()` and `String.prototype.endsWith()`
*   Employing a custom solution using bit manipulation or string indexing techniques
*   Using external libraries like RegEx or String searching algorithms

Related benchmarks:

.includes() vs .test() vs .match() vs .indexOf() (w/ -1 != and !==) (version: 0)

Compare different intra-string matching styles

Comparing performance of: text.includes() vs regex.test() vs string.match() vs string.indexOf() vs string.indexOf() !== -1 vs string.indexOf() != -1

Created: one year ago by: Guest

Jump to the latest result

text.includes()

regex.test()

string.match()

string.indexOf()

string.indexOf() !== -1

string.indexOf() != -1

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