Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
RegEx.test vs. String.includes vs. String.match insensitive
(version: 0)
Comparing performance of:
RegEx.test vs String.includes
Created:
3 years ago
by:
Guest
Go to the latest result
Script Preparation code:
var string = "Hello world!"; var regex = /hello/i;
Tests:
RegEx.test
regex.test(string);
String.includes
string.includes("Hello".toLowerCase());
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
RegEx.test
String.includes
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
3 months ago
)
User agent:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36
Browser/OS:
Chrome 147 on Windows
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=627915" width="100%" height="500px"></iframe>
String.includes
101.9M/s
RegEx.test
68.5M/s
View exact numbers
Test name
Executions per second
✓
String.includes
101,939,552 Ops/sec
RegEx.test
68,460,664 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
**Benchmark Explanation** The provided benchmark, "RegEx.test vs. String.includes vs. String.match insensitive", measures the performance of three different approaches to search for a substring in a string: 1. **Regex.test**: This method uses a regular expression (regex) to test if a specified string matches another string. In this case, it's testing if the input string "hello" matches the original string "Hello world!". The `/i` flag at the end of the regex makes it case-insensitive. 2. **String.includes**: This method checks if a specified value (in this case, the lowercased version of "Hello") is included in a string. 3. **String.match insensitive**: Although not explicitly mentioned in the benchmark definition, we can infer that this refers to using the same regex approach as `RegEx.test`, with the `/i` flag. **Options Compared** The three methods are compared on their execution performance. The benchmark aims to determine which method is the fastest for this specific use case. **Pros and Cons of Each Approach** * **Regex.test**: Pros: + Can be used to test more complex regex patterns. + Can be used in combination with other regex functions (e.g., `regex.test(string)` followed by `regex.exec(string)`). Cons: + May have performance overhead due to the complexity of regex syntax and engine. * **String.includes**: Pros: + Lightweight and simple to use. + No performance overhead due to regex engine. Cons: + Limited functionality compared to regex. + May not perform as well for more complex searches. * **String.match insensitive**: As inferred, this is similar to `RegEx.test` with the `/i` flag. Pros: + Similar performance profile to `RegEx.test`. Cons: Same cons as `RegEx.test`. **Library and Purpose** None are explicitly mentioned in the provided benchmark definition. **Special JS Features or Syntax** There are none mentioned, but it's worth noting that JavaScript's regex engine is quite powerful and can handle complex patterns. If you're interested in testing regex performance, this benchmark might be a good starting point. **Other Alternatives** Some alternative approaches to search for substrings in strings include: 1. **String.prototype.indexOf()**: Similar to `String.includes`, but returns the index of the first occurrence or -1 if not found. 2. **Array.prototype.findIndex()**: Used with an array containing characters or strings to find the index of the first match. 3. **Use a dedicated string matching library**, such as `fn-match` or `fn-matches`, which can provide better performance and flexibility than built-in JavaScript methods. Keep in mind that the choice of approach depends on your specific use case and requirements. For simple substring searches, `String.includes` might be sufficient. For more complex regex patterns or other scenarios, `RegEx.test` or `String.match insensitive` might be a better fit.
Related benchmarks
Case insensitive RegEx.test vs. String.includes when string doesn’t match
RegEx.test vs. String.includes incasesensitive
RegEx.test (with inline regex) vs. String.includes vs. String.match
Case Insensitive RegEx.test vs. String.includes
Comments
Confirm delete:
Do you really want to delete benchmark?