Benchmark: RegEx.test vs. String.includes vs. String.match vs String.indexOf

Script Preparation code:

var string = "Hello world!";
var regex = /Hello/;

Tests:

RegEx.test
regex.test(string);
String.includes
string.includes("Hello");
String.match
string.match("Hello");
String.indexOf
string.indexOf("Hello");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
String.includes
String.match
String.indexOf

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

**What is being tested?**

The provided JSON represents a microbenchmark that compares the performance of three different methods to test if a specific string exists within another string:

1. `String.includes()`
2. `String.indexOf()`
3. `RegEx.test()` (using a regular expression)

These methods are compared in four individual test cases, each with its own unique characteristics.

**Options being compared**

Here's a brief overview of each option and their pros and cons:

1. **`String.includes()`**: This method returns `true` if the specified value is present within the string, and `false` otherwise.
	* Pros: Simple and straightforward implementation, suitable for most use cases.
	* Cons: Can be slow for large strings or when searching for specific patterns.
2. **`String.indexOf()`**: This method returns the index of the first occurrence of the specified value in the string, or -1 if not found.
	* Pros: Fast and efficient for finding exact matches within a small range of characters.
	* Cons: Returns an index instead of a boolean value, requires checking for -1 to determine absence.
3. **`RegEx.test()`**: This method returns `true` if the regular expression pattern is matched at the beginning of the string (the start of the string).
	* Pros: Can be more flexible than `String.includes()` and `String.indexOf()`, suitable for complex patterns and edge cases.
	* Cons: Can be slower due to the overhead of compiling and executing regular expressions.

**Library usage**

In this benchmark, the `RegEx` library is used to create a regular expression pattern (`/Hello/`). This library provides an API for working with regular expressions in JavaScript.

**Special JS features or syntax**

There are no special JavaScript features or syntaxes being tested in this benchmark. The focus is solely on comparing the performance of three different string comparison methods.

**Other alternatives**

If you're interested in exploring alternative string comparison methods, here are a few options:

1. **`String.prototype.startsWith()`**: This method returns `true` if the string starts with the specified value.
2. **`String.prototype.endsWith()`**: This method returns `true` if the string ends with the specified value.
3. **`Array.prototype.includes()`**: This method is similar to `String.includes()`, but applies to arrays instead of strings.

These alternatives might be suitable for specific use cases, but their performance characteristics may vary compared to the methods being tested in this benchmark.

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/109.0.0.0 Safari/537.36

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	8888432.0 Ops/sec
String.includes	21061762.0 Ops/sec
String.match	5044408.0 Ops/sec
String.indexOf	21047628.0 Ops/sec

Related benchmarks:

RegEx.test vs. String.includes vs. String.match vs String.indexOf (version: 0)

Comparing performance of: RegEx.test vs String.includes vs String.match vs String.indexOf

Created: 2 years ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

String.indexOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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