Benchmark: Literal vs Constructor RegExp

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

var elements = Array.of(1000000).fill(0)
var literalRegexps = elements.map(() => /a/)
var constructedRegexps = elements

Tests:

Literal RegExps
literalRegexps.forEach((r) => r.test('aaaa'))
Constructed RegExps
constructedRegexps.forEach((r) => new RegExp('a'.replace(/a/g, 'b')).test('aaaa'))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Literal RegExps
Constructed RegExps

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Literal RegExps	43989120.0 Ops/sec
Constructed RegExps	10458753.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark described in the provided JSON evaluates the performance difference between two ways of creating regular expressions (RegExps) in JavaScript: using literal syntax and using the constructor function.

### Benchmark Overview

#### Options Compared
1. **Literal Regular Expressions**:
   - These are defined using a forward slash syntax, e.g., `/a/`. This approach allows for direct and immediate pattern definition.
   - The test case for this approach is: 
     ```javascript
     literalRegexps.forEach((r) => r.test('aaaa'))
     ```
   - Here, `literalRegexps` is an array filled with a million instances of the `/a/` RegExp.

2. **Constructed Regular Expressions**:
   - These are created using the `RegExp` constructor, e.g., `new RegExp('a')`. This approach allows for dynamic construction of regex patterns, which can be useful when regex patterns are determined at runtime.
   - The test case for this approach is:
     ```javascript
     constructedRegexps.forEach((r) => new RegExp('a'.replace(/a/g, 'b')).test('aaaa'))
     ```
   - In this example, `constructedRegexps` is an array of zeros which are intended to represent instances where RegExp is constructed anew in each iteration.

### Pros and Cons of Each Approach

#### Literal Regular Expressions
- **Pros**:
  - **Performance**: The benchmarks show that literal regexps are significantly faster. In the test results, they achieved approximately 43,989,120 executions per second.
  - **Readability**: They tend to be more concise and easier to read and understand.
  
- **Cons**:
  - **Static Nature**: They are not dynamically generated; this can limit their flexibility in certain situations where regex patterns are determined based on user input or other runtime data.

#### Constructed Regular Expressions
- **Pros**:
  - **Dynamism**: They allow for the entire pattern to be generated dynamically at runtime, which is useful in cases where the pattern is dependent on variables or external input.
  
- **Cons**:
  - **Performance**: The benchmark indicates a notable performance drawback, with around 10,458,753 executions per second, making them less efficient than literal regexps.
  - **Verbosity**: The syntax can be more verbose, which can detract from readability.

### Other Considerations
- **Regex Construction Overhead**: When using constructed regex patterns inside a loop, a new RegExp object is created during each iteration, which incurs additional overhead. This overhead is a significant factor in the performance difference observed in the benchmark.
- **Repetition of Dynamic Patterns**: If the same dynamic pattern is needed multiple times, it's usually more efficient to construct it once and reuse the same RegExp instance.

### Alternatives
1. **Memoization**: For cases where constructed RegExp patterns are used repeatedly, memoizing the created regex can help. This technique involves storing computed values (in this case, RegExp objects) so they can be reused, minimizing the performance overhead.
   
2. **Template Literals**: For concatenating strings used in regex, template literals can simplify dynamic creation while maintaining performance if they can be combined with precompiled regex patterns.
   
3. **Performance Profiling**: Using performance profiling tools can assist developers in determining the best approach based on their specific scenarios.

In summary, for scenarios where the regex pattern is static, using literal regex will generally offer better performance and code clarity. However, if you require dynamic patterns, consider the overhead of constructing RegExp objects and potential strategies for optimizing performance.

Related benchmarks:

Literal vs Constructor RegExp (version: 1)

Comparing performance of: Literal RegExps vs Constructed RegExps

Created: 2 months ago by: Guest

Jump to the latest result

Literal RegExps

Constructed RegExps

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):