Benchmark: .includes() vs .test() vs .replace() 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.replace(/matchthis/ig, '')
string.indexOf()
url.indexOf('matchthis') >= 0

Historical Performance Data aggregated from 15 community runs

Desktop Results:

Chrome 15 runs

text.includes()

26.7M/s

string.indexOf()

26.4M/s

regex.test()

14.9M/s

string.match()

9.8M/s

Fastest: text.includes() (2.7x faster)

View exact numbers

✓ text.includes(): 26,727,032 ops/sec
• string.indexOf(): 26,363,750 ops/sec
• regex.test(): 14,873,630 ops/sec
• string.match(): 9,800,356 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: 10 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:140.0) Gecko/20100101 Firefox/140.0

Browser/OS: Firefox 140 on Windows

View result in a separate tab

text.includes()

698.9M/s

string.indexOf()

684.2M/s

regex.test()

14.0M/s

string.match()

5.3M/s

View exact numbers

Test name	Executions per second
✓ text.includes()	698,914,048 Ops/sec
string.indexOf()	684,237,376 Ops/sec
regex.test()	13,969,979 Ops/sec
string.match()	5,263,850 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested on the provided JSON and explain the differences between the various approaches.

**Overview**

The benchmark compares four different methods for intra-string matching:

1. `.includes()`
2. `.test()` (using regular expressions)
3. `.replace()` with a regular expression
4. `.indexOf()`

**Options Compared**

Here's a brief overview of each method:

* `includes()`: This method returns `true` if the specified value is found within the string, and `false` otherwise. It uses a simple substring search.
* `.test()`: This method executes the provided regular expression against the entire string and returns `true` or `false` depending on whether the regex matches.
* `.replace()` with a regular expression: This method replaces all occurrences of the specified value in the string with an empty string. It uses a similar approach to `.test()`, but with the added step of removing the matched value from the original string.
* `.indexOf()`: This method returns the index of the first occurrence of the specified value within the string, or `-1` if not found.

**Pros and Cons**

Here are some pros and cons for each approach:

* `includes()`: Pros - simple, fast. Cons - may return false positives (e.g., "hello" in "hello world"), less efficient than other methods.
* `.test()`: Pros - flexible, can match more complex patterns. Cons - slower than `includes()` due to the overhead of regular expression execution.
* `.replace()` with a regular expression: Pros - flexible, can be used for replacement. Cons - slower and more memory-intensive than `includes()` or `.test()`.
* `.indexOf()`: Pros - simple, fast. Cons - only returns an index value, doesn't provide information about the matched position.

**Library Usage**

There is no explicit library usage mentioned in the provided JSON. However, it's worth noting that some of these methods rely on the underlying string manipulation functions, which are typically part of the JavaScript engine itself.

**Special JS Features or Syntax**

No special features or syntax are explicitly used in this benchmark. The tests focus solely on the method comparisons.

**Other Alternatives**

For those interested in exploring alternative approaches, here are a few options:

* `String.prototype.localeCompare()`: This method compares two strings using a locale-specific comparison algorithm.
* `RegExp.exec()`: This method executes a regular expression against a string and returns an array of matches or null if no match is found.

These alternatives may provide different trade-offs in terms of performance, flexibility, and simplicity, but are not part of the original benchmark.

.includes() vs .test() vs .replace() 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: Guest

Go to the latest result

text.includes()

regex.test()

string.match()

string.indexOf()

Historical Performance Data aggregated from 15 community runs

Desktop Results:

Chrome 15 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

.includes() vs .test() vs .replace() 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: Guest

Go to the latest result

text.includes()

regex.test()

string.match()

string.indexOf()

Historical Performance Data aggregated from 15 community runs

Desktop Results:

Chrome 15 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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