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

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");

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

Latest run results:

Run details: (Test run date: 10 hours ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0

Browser/OS: Chrome 135 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	35729460.0 Ops/sec
String.includes	109097128.0 Ops/sec
String.match	6214421.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data to understand what's being tested and compare different approaches.

**Benchmark Definition**

The benchmark is testing three approaches for searching a specific substring in a string:

1. `RegEx.test()`: This approach uses regular expressions (regex) to search for the substring.
2. `String.includes()`: This approach uses the `includes()` method of the String object, which checks if a certain value exists within the string.
3. `String.match()`: This approach uses the `match()` method of the String object, which searches for a pattern in the string and returns an array of matches.

**Options Compared**

The benchmark is comparing these three approaches to measure their performance difference.

**Pros and Cons of Each Approach**

1. **RegEx.test()**:
	* Pros: Can be very efficient if used correctly, as it uses a specialized engine optimized for regex matching.
	* Cons: Can be slower due to the overhead of the regex engine, especially for complex patterns. Also, can be vulnerable to performance issues if not properly configured or maintained.
2. **String.includes()**:
	* Pros: Fast and lightweight, as it's implemented in native code. It's also relatively simple to use and doesn't require any setup or configuration.
	* Cons: May not perform well with large strings or complex searches, as it uses a naive approach that may involve iterating over the entire string.
3. **String.match()**:
	* Pros: Similar to `includes()`, but offers more flexibility in terms of pattern matching and can be faster for certain use cases. However, it's also relatively lightweight and easy to use.
	* Cons: May have slightly higher overhead than `includes()` due to the additional complexity of pattern matching.

**Library/Functionality Used**

None of these functions rely on external libraries. They are all part of the built-in JavaScript API.

**Special JS Feature/Syntax**

There is no special JavaScript feature or syntax being used in this benchmark. It's purely functional programming, with a focus on comparing different approaches for substring searching.

**Other Alternatives**

If you're interested in exploring alternative approaches to substring searching, here are some options:

1. **Using a dedicated regex library**: For more complex or optimized regex patterns, using a dedicated library like `regex-escape` or `regex-test` might be beneficial.
2. **Using a custom implementation**: Depending on your specific use case and requirements, you might consider implementing your own substring searching algorithm from scratch.
3. **Using other built-in methods**: Besides `includes()` and `match()`, you could also explore using other built-in methods like `indexOf()` or `lastIndexOf()` for substring searching.

Keep in mind that the performance differences between these approaches can be significant, especially for large strings or complex searches. The benchmark data provides valuable insights into which approach is most efficient under different conditions.

Related benchmarks:

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

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

Created: 3 years 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 6 months ago):