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

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

Test name	Executions per second
text.includes()	698914048.0 Ops/sec
regex.test()	13969979.0 Ops/sec
string.match()	5263850.5 Ops/sec
string.indexOf()	684237376.0 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.

Related benchmarks:

.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

Jump to the latest result

text.includes()

regex.test()

string.match()

string.indexOf()

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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