Benchmark: RegExp.test() vs RegExp.match()

Script Preparation code:

var reStr = '^[0-9]+$';
var re = new RegExp(re);

Tests:

RegExp.test()
!re.test('123');
RegExp.match()
!reStr.match('123');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegExp.test()
RegExp.match()

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36

Browser/OS: Chrome 113 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
RegExp.test()	14949047.0 Ops/sec
RegExp.match()	5434404.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided JSON represents a benchmark test case that compares two different approaches to regular expression testing: `RegExp.test()` and `RegExp.match()`. Here's what's tested:

**Tested options:**

1. **`RegExp.test()`**: This method tests whether the specified string matches the pattern in the regular expression.
2. **`RegExp.match()`**: This method searches for the first occurrence of the pattern in the string.

**Pros and cons:**

* `RegExp.test()`: Pros:
	+ Typically faster, as it only checks for a single match.
	+ May be more efficient for simple patterns.
Cons:
	+ May return false positives (false matches) if the input string is not null-terminated.
	+ Can be slower for complex patterns or large input strings.
* `RegExp.match()`:
	+ Pros:
		- More intuitive, as it returns an array of all non-overlapping matches in the entire string.
		- Can handle multi-line inputs and anchors like `^` and `$`.
	+ Cons:
		- May be slower due to the overhead of compiling the regular expression and searching for multiple matches.
		- Returns false if no match is found, whereas `RegExp.test()` returns `false` only if the input string is null or undefined.

**Library usage:**

In this benchmark, a `RegExp` object is created using the `new RegExp()` constructor, passing in a regular expression pattern as a string. The pattern used is `^[0-9]+$`, which matches one or more digits from start to end of the string (inclusive).

**Special JavaScript features/syntax:**

There are no notable special features or syntax used in this benchmark.

Now, let's consider alternative approaches:

* **Using a native method**: Depending on the JavaScript engine and platform, `RegExp.test()` might be implemented using a native method like `String.prototype.match()`. In this case, the benchmark would still compare the performance of `RegExp.test()` to the native implementation.
* **Using a different regular expression library**: If you were to use a different regular expression library (e.g., Sizzle or jQuery's `RegExp`), the benchmark results might vary due to differences in optimization strategies and implementation details.

Keep in mind that JavaScript engines can vary significantly, which may affect the performance of these benchmarks. The MeasureThat.net website attempts to account for this by running each test case multiple times with different environments (browsers) and devices, providing a more comprehensive view of the results.

Related benchmarks:

RegExp.test() vs RegExp.match() (version: 0)

Comparing performance of: RegExp.test() vs RegExp.match()

Created: 5 years ago by: Guest

Jump to the latest result

RegExp.test()

RegExp.match()

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