Benchmark: RegExp constructor vs literal + instanciation

Tests:

new RegExp()
new RegExp('^[0-9a-fA-F]{24}$').test('132abc67219f019afe12901a')
Literal
/^[0-9a-fA-F]{24}$/.test('132abc67219f019afe12901a')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new RegExp()
Literal

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/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
new RegExp()	8591375.0 Ops/sec
Literal	14857931.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

The benchmark titled **"RegExp constructor vs literal + instantiation"** is designed to evaluate the performance differences between using a **RegExp constructor** (`new RegExp`) and a **regular expression literal** (defined with slashes `/.../`) when testing patterns against input strings in JavaScript. The test specifically checks the execution speed of both approaches for running regular expression tests.

### Test Cases

1. **Test Case: `new RegExp('^[0-9a-fA-F]{24}$').test('132abc67219f019afe12901a')`**
   - **Test Name**: "new RegExp()"
   - This test creates a new instance of a regular expression object using the constructor `new RegExp()`. It evaluates whether the input string `'132abc67219f019afe12901a'` matches the pattern defined—in this case, checking for a hexadecimal string of exactly 24 characters.
   
2. **Test Case: `/^[0-9a-fA-F]{24}$/.test('132abc67219f019afe12901a')`**
   - **Test Name**: "Literal"
   - This test applies a regular expression literal to check the same input against the same criteria as the previous test using a more concise syntax with a literal.

### Performance Results

The benchmark results indicate:
- **Literal Method**: Approximately **14,857,931 executions per second**.
- **RegExp Constructor Method**: Approximately **8,591,375 executions per second**.

### Pros and Cons of Each Approach

**1. Regular Expression Literal**
   - **Pros**:
     - Generally faster execution, as indicated by the benchmark results.
     - Easier to read and write for most use cases, as it follows a more concise syntax.
     - Compiled at parse time, which can lead to improved speed since the JavaScript engine can optimize it directly.
   - **Cons**:
     - Less flexible if you need to dynamically construct the pattern. You cannot use variables to form the regex easily.

**2. RegExp Constructor**
   - **Pros**:
     - Allows for dynamic creation of regex patterns using variables, making it easy to alter the expression at runtime.
     - Useful in scenarios where the pattern requires runtime information, such as user input.
   - **Cons**:
     - Slower performance compared to literals.
     - Requires the pattern to be provided as a string, which can be less readable and might need additional escape characters.

### Other Considerations

- In typical scenarios where the pattern is static, favoring regex literals can improve performance.
- In cases requiring dynamic regex patterns, the constructor becomes a necessary choice despite the performance overhead.
- If you need to use patterns periodically, pre-compiling a regex with the constructor and reusing it can mitigate some performance drawbacks.

### Alternatives

- **String Matching**: If exact string matches are needed without regex complexity, using simple string comparison methods like `String.includes()`, `String.startsWith()`, or `String.endsWith()` might yield better performance.
- **Third-Party Libraries**: Libraries like **XRegExp** provide extended capabilities for regex that go beyond standard JavaScript regex features and may optimize performance in some specific complex use cases.

By understanding the differences between using a regex constructor and regex literals, engineers can make informed decisions tailored to their specific application requirements, balancing readability, performance, and flexibility.

Related benchmarks:

RegExp constructor vs literal + instanciation (version: 1)

Testing performance when using a new RegExp object vs a literal regex

Comparing performance of: new RegExp() vs Literal

Created: one year ago by: Guest

Jump to the latest result

new RegExp()

Literal

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):