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

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.startsWith
string.startsWith("Hello");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 17 on iOS 17.0

View result in a separate tab

Test name	Executions per second
RegEx.test	5568804.5 Ops/sec
String.includes	8018066.0 Ops/sec
String.match	3985646.8 Ops/sec
String.startsWith	8293765.5 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 provided benchmark and explain what's being tested, along with the pros and cons of each approach.

**Benchmark Overview**

The provided benchmark compares the performance of four string manipulation functions:

1. `String.startsWith`
2. `String.includes`
3. `RegExp.test`

These functions are used to check if a given string contains a specific pattern or sequence of characters.

**Options Being Compared**

Here's what's being compared for each function:

* `String.startsWith` vs `String.includes`: Both functions check if the input string starts with a specified prefix. However, `String.startsWith` is more efficient because it stops searching as soon as it finds the match.
* `RegExp.test` vs other two options: `RegExp.test` is a more general-purpose function that can be used to test for any pattern, not just prefixes or substrings.

**Pros and Cons**

1. `String.startsWith`
	* Pros: Efficient, simple implementation.
	* Cons: Only checks for prefix matches, may not work as expected with Unicode characters.
2. `String.includes`
	* Pros: Works with Unicode characters, easy to implement.
	* Cons: Less efficient than `String.startsWith`, may use more CPU cycles to search for the match.
3. `RegExp.test`
	* Pros: Highly flexible, can be used to test for any pattern.
	* Cons: May be slower due to the overhead of creating a regular expression object.

**Library and Purpose**

In this benchmark, `RegExp` is being used to create regular expressions (`regex = /Hello/;`). The `RegExp.test` function uses these regular expressions to check if the input string matches the pattern.

**Special JS Feature or Syntax**

There isn't any special JavaScript feature or syntax mentioned in this benchmark. However, it's worth noting that modern JavaScript engines have optimized implementations of these functions, which can affect performance.

**Other Alternatives**

Other alternatives for checking prefix or substring matches could be:

* `indexOf()`: A built-in method that searches for the specified value within a string and returns its index.
* `lastIndexOf()`: Similar to `indexOf`, but searches from the end of the string instead.

Keep in mind that these methods may have different performance characteristics compared to `String.startsWith` and `String.includes`.

Related benchmarks:

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

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

Created: one year ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

String.startsWith

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