Benchmark: RegEx.test vs. String.includes vs. String.match (2000 character)

Script Preparation code:

var string = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin eget tincidunt lacus, eget suscipit massa. Pellentesque tempor rutrum semper. Vestibulum eget lacus commodo, luctus libero quis, commodo sapien. Sed sagittis eu velit vitae dapibus. Donec viverra, sapien ac porta aliquet, risus est aliquet lectus, vitae maximus mauris diam vitae mi. Morbi in arcu lorem. Maecenas accumsan finibus varius. Nullam pellentesque id sem eu molestie. Sed ut urna risus. Donec venenatis at tellus vel posuere. Mauris vitae malesuada neque. Nullam bibendum maximus nisi. Praesent finibus porta risus, a rhoncus massa ultrices a. Aenean gravida justo at arcu sodales consectetur. Maecenas lobortis commodo nunc, sed tempor massa finibus non. Pellentesque a ante a lorem convallis commodo. Suspendisse potenti. Maecenas blandit eu arcu eget bibendum. Curabitur cursus quam eleifend fermentum molestie. Sed lacinia aliquam eleifend. Phasellus vel placerat velit, eu posuere tortor. Aenean varius mauris ut luctus faucibus. Nullam ut lacus in erat imperdiet venenatis. Duis suscipit nibh nec tristique tempus. Suspendisse nec lacus lacus. Pellentesque finibus pellentesque purus. Sed erat lorem, mollis ac metus a, volutpat facilisis lorem. Etiam venenatis commodo purus, vel dignissim felis sodales id. Curabitur ac volutpat nisi. Mauris ultricies odio nec enim tincidunt consequat non nec libero. Vestibulum faucibus elementum gravida. Curabitur vitae nibh quis leo gravida varius ut ac magna. Sed posuere feugiat dignissim. Integer nec auctor purus. Vestibulum ipsum neque, volutpat id nisl auctor, dictum interdum mi. Suspendisse commodo eros id pellentesque iaculis. Proin luctus purus elit, sit amet lobortis dolor lacinia vitae. Nullam lobortis sit amet nunc quis bibendum. Praesent ac nisl id lectus fermentum porta ut eget erat. Nullam vel ligula congue lectus faucibus gravida. Praesent condimentum semper orci, vitae maximus neque bibendum sit amet. Fusce pellentesque at felis eu sodales. Suspendisse augue.";
var regex = /tortor/;

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark is designed to compare three different approaches for searching a string:

1. `RegEx.test()`: A regular expression method to test if a string contains a specified pattern.
2. `string.includes()`: A built-in JavaScript method to check if a string includes another string or substring.
3. `string.match()`: Another regular expression method to find the first match of a pattern in a string.

**Script Preparation Code**

The script preparation code defines:

* A 2000-character string `string` containing some text with the word "tortor" multiple times.
* A regular expression object `regex` that matches only the word "tortor".

**Html Preparation Code**

There is no HTML preparation code provided, so this step can be skipped.

**Individual Test Cases**

The benchmark consists of three individual test cases:

1. `RegEx.test()`: This test case runs the `RegEx.test()` method on the prepared string with the `regex` object.
2. `String.includes()`: This test case runs the `includes()` method on the prepared string with the substring "tortor".
3. `String.match()`: This test case runs the `match()` method on the prepared string with the regular expression `regex`.

**Comparison**

The benchmark compares the execution time of each test case across different browsers and devices:

* The raw UA string, browser version, device platform, operating system, executions per second (FPS), and test name are provided for each test case.

**Pros and Cons**

Here's a brief analysis of the pros and cons for each approach:

1. `RegEx.test()`:
	* Pros: Can be more flexible than `includes()` or `match()` when dealing with complex patterns.
	* Cons: Regular expression syntax can be error-prone, slow, and resource-intensive compared to built-in methods.
2. `string.includes()`:
	* Pros: Fast, lightweight, and easy to use for simple substring searches.
	* Cons: Can be slower than regular expressions for more complex searches or when using Unicode characters.
3. `string.match()`:
	* Pros: Similar to `includes()`, but can capture multiple matches if needed.
	* Cons: Slower than `RegEx.test()` and may be less flexible.

**Other Considerations**

When choosing between these approaches, consider the following factors:

* Complexity of the search pattern
* Performance requirements (e.g., real-time or high-throughput applications)
* Character encoding and Unicode support

**Alternatives**

Some alternative methods for string searching could include:

1. `RegExp.prototype.test()`: Similar to `RegEx.test()`, but with more flexibility in regular expression syntax.
2. `String.prototype.startsWith()`/`String.prototype.endsWith()`: For prefix or suffix matching, respectively.
3. Regular expressions with character classes (e.g., `\w+`) for simple word searches.

Keep in mind that the best approach will depend on the specific requirements of your use case and performance constraints.

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

Browser/OS: Chrome 110 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	1732790.9 Ops/sec
String.includes	15712028.0 Ops/sec
String.match	1523860.1 Ops/sec

Related benchmarks:

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

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

Created: one year ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

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