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

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");
equal operator
string === "Hello"

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 5 months ago)

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

Browser/OS: Chrome 143 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	39200428.0 Ops/sec
String.includes	137542176.0 Ops/sec
String.match	9410347.0 Ops/sec
equal operator	135518000.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested in this specific benchmark.

**Benchmark Overview**

The benchmark measures the performance of four different ways to check if a string contains the substring "Hello":

1. `regex.test(string)`
2. `string.includes("Hello")`
3. `string.match("Hello")`
4. Using the equality operator (`string === "Hello"`)

**Options Being Compared**

Each option is compared in terms of its execution time, with the goal of identifying which one performs the best.

**Pros and Cons of Each Approach:**

1. **`regex.test(string)`**: This method uses a regular expression engine to test if the string contains the substring "Hello". Pros:
	* Can be used for more complex pattern matching.
	* Can be optimized for performance with techniques like caching and memoization.
Cons:
	* May be slower than other methods due to the overhead of parsing regular expressions.
2. **`string.includes("Hello")`**: This method uses the `includes()` method, which checks if a string contains a specified value (in this case, "Hello"). Pros:
	* Fast and efficient, as it's implemented in native code.
Cons:
	* May not be suitable for complex pattern matching or multi-character substrings.
3. **`string.match("Hello")`**: This method uses the `match()` method, which attempts to find a regular expression match in a string. Pros:
	* Can be used for more complex pattern matching.
Cons:
	* May be slower than other methods due to the overhead of parsing regular expressions and attempting matches.
4. **`string === "Hello"`**: This method uses the equality operator to compare the string with the literal value "Hello". Pros:
	* Simple and easy to understand.
Cons:
	* May not be suitable for large strings, as it creates a new object reference.

**Library Used:**

None of these methods rely on external libraries. However, if we were to implement these methods using third-party libraries, `String.prototype.includes()` might use the `strrep` method from the Intl.Collator API or the `indexOf()` method, which is implemented in native code and is relatively fast.

**Special JS Feature/Syntax:**

None of these methods rely on special JavaScript features or syntax beyond what's standard. The benchmark focuses on comparing the performance of basic string comparison methods.

**Other Alternatives:**

If you need to optimize string matching or pattern searching, you might consider using libraries like:

1. `regex`: A popular library for regular expressions in Node.js.
2. `string-prompt**: A library that provides fast and efficient string operations, including includes() and matches().
3. `fast-regex`: Another library that provides optimized regex functionality.

Keep in mind that the performance of these alternatives will depend on the specific use case and requirements of your project.

**Conclusion:**

In this benchmark, we're comparing the performance of four basic methods for checking if a string contains the substring "Hello". By understanding the pros and cons of each approach, you can make informed decisions about which method to use in your own projects.

Related benchmarks:

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

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

Created: 3 years ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

equal operator

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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