Benchmark: RegEx.test (various styles) vs. String.includes vs. String.match vs. String Equality vs. String.indexOf

Script Preparation code:

var string = "v1.1";
var regex = /^v1(\.\w+)*$/;
var regex2 = /v1(\.\w+)*/;
var regexBase = /v1/;

Tests:

RegEx.test
regex.test(string);
String.includes
string.includes("v1");
String.match
string.match("v1.1");
String Equality
string === "v1.1"
String.indexOf
string.indexOf("v1") === 0
Regex.test no ^ and &
regex2.test(string);
Regex.test base
regexBase.test(string);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
String.includes
String.match
String Equality
String.indexOf
Regex.test no ^ and &
Regex.test base

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 98 on Windows 7

View result in a separate tab

Test name	Executions per second
RegEx.test	3195214.8 Ops/sec
String.includes	6041590.5 Ops/sec
String.match	2136097.8 Ops/sec
String Equality	7844748.5 Ops/sec
String.indexOf	7902571.5 Ops/sec
Regex.test no ^ and &	3212215.8 Ops/sec
Regex.test base	3041943.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The benchmark compares six different approaches for testing string equality and regular expression matching:

1. `String.includes()`
2. `String.match()` (with and without anchors)
3. `String Equality` using the triple equals operator (`===`)
4. `String.indexOf()` (returns the index of the first occurrence)
5. `regex.test()` (a custom implementation)
6. `regexBase.test()` (a simplified version of `regex.test()`)

**Options Compared**

The benchmark compares three main options:

* **Anchored vs. Non-Anchored Regex**: The first option (`regex2`) uses a regular expression without anchors (`^` and `$`), while the second option (`regexBase`) uses a simplified version with only the prefix anchor (`v1/`).
* **String Equality using `===`**: This approach directly compares two strings using the triple equals operator.
* **Built-in String Methods**: The benchmark also tests three built-in string methods: `includes()`, `match()`, and `indexOf()`.

**Pros and Cons of Each Approach**

Here's a brief summary of each approach:

1. **Anchored vs. Non-Anchored Regex**:
	* Anchored regex provides more precise matching but can be slower due to the overhead of anchors.
	* Non-anchored regex is generally faster but may return false positives or non-matches.
2. **String Equality using `===`**:
	* This approach is simple and fast but may not work correctly for all edge cases (e.g., null, undefined, or NaN values).
3. **Built-in String Methods**:
	* These methods are often faster than custom implementations but may have varying levels of precision depending on the method.
	* `includes()` can return early if the string is found, which might not be desirable in all cases.

**Library: None**

There are no external libraries used in this benchmark. All tests use built-in JavaScript features and string manipulation functions.

**Special JS Features or Syntax**

The only special feature mentioned is the use of anchors (`^` and `$`) in regular expressions, which can affect performance but provide more precise matching.

**Other Alternatives**

If you were to implement a similar benchmark, you might consider testing other approaches, such as:

* Using `String.prototype.localeCompare()` for string comparison
* Implementing a custom regex engine or parser
* Testing other built-in JavaScript methods like `replace()`, `split()`, or `substring()`

Keep in mind that each approach has its strengths and weaknesses, and the best choice will depend on your specific use case and performance requirements.

Related benchmarks:

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

Comparing performance of: RegEx.test vs String.includes vs String.match vs String Equality vs String.indexOf vs Regex.test no ^ and & vs Regex.test base

Created: one year ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

String Equality

String.indexOf

Regex.test no ^ and &

Regex.test base

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