Benchmark: Regex construction vs execution

Regex construction vs execution (version: 0)

Compare literal and string construction of Regex with exec() leverage a pattern with and without captures.

Comparing performance of: simple literal compilation vs simple constructor compilation vs constructor compilation with capture vs literal compilation with capture vs Execute literal simple vs Execute literal with capture

Created: 5 months ago by: Registered User

Jump to the latest result

Script Preparation code:

var constructorSimple = new RegExp('^[0-9a-fA-F]{24}$');
var literalSimple = /^[0-9a-fA-F]{24}$/;
var constructorWithCapture = new RegExp('My phone number is (?<phone>\d{3}-\d{3}-\d{4}).', 'g');
var literalWithCapture = /My phone number is (?<phone>\d{3}-\d{3}-\d{4})./g;

Tests:

simple literal compilation
var testLiteralSimple = /^[0-9a-fA-F]{24}$/;
simple constructor compilation
var testConstructorSimple = new RegExp('^[0-9a-fA-F]{24}$');
constructor compilation with capture
var testConstructorWithCapture = new RegExp('My phone number is (?<phone>\d{3}-\d{3}-\d{4}).', 'g');
literal compilation with capture
var testLiteralWithCapture = /My phone number is (?<phone>\d{3}-\d{3}-\d{4})./g;
Execute literal simple
const result = literalSimple.exec('132abc67219f019afe12901a');
Execute literal with capture
const result = literalWithCapture.exec('My phone number is 555-123-4567.');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
simple literal compilation
simple constructor compilation
constructor compilation with capture
literal compilation with capture
Execute literal simple
Execute literal with capture

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares different approaches to compiling and executing regular expressions (Regex) in JavaScript:

1. Literal construction vs. execution
2. Two approaches for constructing Regex: `new RegExp()` and `/regex/`
3. Two test cases for each approach: simple literal compilation and constructor compilation with or without captures.

**Options Compared**

The benchmark compares the following options:

* **Literal construction**: Using the `/regex/` syntax to define a regular expression literal, such as `var literalSimple = /^[0-9a-fA-F]{24}$/;`.
* **Constructor creation**: Creating a new `RegExp` object using the `new RegExp()` syntax, such as `var constructorSimple = new RegExp('^[0-9a-fA-F]{24}$');`.

**Pros and Cons**

Here are some pros and cons of each approach:

### Literal Construction

Pros:

* Faster compilation time
* Less overhead compared to constructor creation
* More concise code

Cons:

* Limited flexibility, as the pattern cannot be modified after construction
* May not support certain features, such as captures or flags

### Constructor Creation

Pros:

* Flexibility: patterns can be modified or extended after creation
* Support for captures and flags
* Can be useful when working with complex Regex patterns

Cons:

* Slower compilation time compared to literal construction
* More verbose code

**Library Used**

The benchmark uses the built-in `RegExp` object in JavaScript, which provides a way to create and manipulate regular expressions. The library is part of the JavaScript standard library.

**Special JS Feature or Syntax**

No special JS feature or syntax is used in this benchmark.

**Other Considerations**

When working with Regex, it's essential to consider factors such as:

* Performance: How quickly does the code execute?
* Code readability and maintainability
* Error handling and edge cases

**Alternatives**

If you're looking for alternative approaches to compiling and executing regular expressions, consider the following options:

1. **RegExxer**: A JavaScript library that provides a more efficient way of working with Regex.
2. **URegex**: Another JavaScript library that offers improved performance and features compared to the built-in `RegExp` object.

Keep in mind that the best approach depends on your specific use case, performance requirements, and code readability goals.

I hope this explanation helps!

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/125.0.0.0 Safari/537.36 Edg/125.0.0.0

Browser/OS: Chrome 125 on Windows

View result in a separate tab

Test name	Executions per second
simple literal compilation	108781504.0 Ops/sec
simple constructor compilation	4884616.0 Ops/sec
constructor compilation with capture	4426632.5 Ops/sec
literal compilation with capture	111682368.0 Ops/sec
Execute literal simple	5888442.0 Ops/sec
Execute literal with capture	7170987.5 Ops/sec

Related benchmarks:

Regex construction vs execution (version: 0)

Compare literal and string construction of Regex with exec() leverage a pattern with and without captures.

Comparing performance of: simple literal compilation vs simple constructor compilation vs constructor compilation with capture vs literal compilation with capture vs Execute literal simple vs Execute literal with capture

Created: 5 months ago by: Registered User

Jump to the latest result

simple literal compilation

simple constructor compilation

constructor compilation with capture

literal compilation with capture

Execute literal simple

Execute literal with capture

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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