Benchmark: String vs regex - MeasureThat.net

Script Preparation code:

var string = "Hello world!";
var regex = /[A-Z][a-z]+ [a-z]+/;

Tests:

inline regex test (1)
/[A-Z][a-z]+ [a-z]+/.test(string);
reference regex test (2)
regex.test(string);
inline match (3)
string.match(/[A-Z][a-z]+ [a-z]+/);
reference match (4)
string.match(regex);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
inline regex test (1)
reference regex test (2)
inline match (3)
reference match (4)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**What is being tested?**

MeasureThat.net is testing the performance of different approaches to regular expression matching in JavaScript:

1. Using the `test()` method on a RegExp object (`regex.test(string);`).
2. Using the `test()` method on a String prototype (`string.match(regex);`).
3. Creating an inline RegExp and using its `match()` method on a String (`string.match(/[A-Z][a-z]+ [a-z]+/);`).

**Options compared**

The benchmark is comparing two approaches:

1. **Reference approach**: Using the `test()` method on a RegExp object.
2. **Inline approach**: Creating an inline RegExp and using its `match()` method on a String.

**Pros and cons of each approach**

**Reference approach (using `test()` method on a RegExp object)**

Pros:

* More readable and maintainable code
* Easier to test and debug individual components
* Can be more efficient if the regular expression is complex or used in multiple places

Cons:

* Requires creating a new RegExp object, which can lead to slower performance due to the overhead of creating an object.
* May require additional setup or configuration.

**Inline approach (creating an inline RegExp)**

Pros:

* Can lead to faster execution times since the RegExp object is created only once and reused.
* Can be more efficient if the regular expression is simple or used in a small number of places.

Cons:

* Less readable and maintainable code, making it harder to understand and debug individual components.
* Can make it harder to test and debug individual components due to the complexity of the inline RegExp.

**Other considerations**

* The choice between these approaches can also depend on the specific requirements of the project, such as performance-critical code or complex regular expressions.
* Additionally, other factors like browser support, engine-specific optimizations, and caching mechanisms can impact the performance difference between these approaches.

**Library usage (none)**

There is no library used in this benchmark. The RegExp object and String prototype are native JavaScript objects.

**Special JS feature or syntax (none)**

This benchmark does not use any special JavaScript features or syntax beyond standard regular expression matching.

Now, let's discuss the latest benchmark results:

The latest results show that the inline approach leads to faster execution times for all test cases. However, it's essential to note that these results may vary depending on specific requirements and project constraints.

**Alternatives**

Other alternatives to consider when choosing between these approaches include:

* Using a library like RegExr or regex101 to optimize regular expression patterns.
* Leveraging browser-specific optimizations or engine-specific features (e.g., WebAssembly, V8's String internals).
* Considering the use of alternative matching techniques, such as using an inlined state machine or using the `String.prototype.replace()` method with a callback function.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:95.0) Gecko/20100101 Firefox/95.0

Browser/OS: Firefox 95 on Mac OS X 10.14

View result in a separate tab

Test name	Executions per second
inline regex test (1)	19269174.0 Ops/sec
reference regex test (2)	19999594.0 Ops/sec
inline match (3)	12673832.0 Ops/sec
reference match (4)	13071716.0 Ops/sec

Related benchmarks:

String vs regex (version: 0)

Comparing performance of: inline regex test (1) vs reference regex test (2) vs inline match (3) vs reference match (4)

Created: 2 years ago by: Guest

Jump to the latest result

inline regex test (1)

reference regex test (2)

inline match (3)

reference match (4)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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