Benchmark: how fast is regex2?

Script Preparation code:

const prepared = /[.*+?^${}()|[\]\\]/g;

Tests:

instantiate new regex
const blah = "whatever" const r = blah.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
use existing regex
const blah = "whatever" const r = blah.replace(prepared, "\\$&")
just make a string
const blah = "foo"

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
instantiate new regex
use existing regex
just make a string

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
instantiate new regex	14204612.0 Ops/sec
use existing regex	14546226.0 Ops/sec
just make a string	167660256.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON is focused on evaluating the performance of different approaches to using regular expressions (regex) in JavaScript, specifically comparing the efficiency of instantiating a new regex against using an existing pre-compiled regex. Here’s a breakdown of the relevant components and insights from the benchmark.

### Benchmark Preparation Code
The preparation code defined is:
```javascript
const prepared = /[.*+?^${}()|[\\]\\\\]/g;
```
This line of code compiles a regex pattern, which is designed to match special characters commonly used in regex expressions. The compiled regex is stored in the variable `prepared`, allowing it to be reused in multiple test cases without being recompiled each time, thereby improving performance in subsequent operations.

### Individual Test Cases
1. **Instantiate New Regex**
   ```javascript
   const blah = "whatever";
   const r = blah.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&");
   ```
   - **Description**: This test case defines a regex pattern inline and uses it for the replacement operation. The regex is re-instantiated for each benchmark run.
   - **Pros**: This approach might be straightforward for individual tests where the regex pattern is unique to the operation.
   - **Cons**: The performance cost of compiling the regex can be significant if used multiple times, especially in larger loops or repeated calls.

2. **Use Existing Regex**
   ```javascript
   const blah = "whatever";
   const r = blah.replace(prepared, "\\$&");
   ```
   - **Description**: This test case uses the pre-compiled regex stored in the `prepared` variable.
   - **Pros**: Utilizing an existing regex avoids the overhead of compiling the regex each time it’s needed, resulting in better performance. It is a more optimal use of resources when the regex will be applied multiple times.
   - **Cons**: This method requires an initial setup (compiling the regex), and it may not be as flexible if the pattern needs to change frequently.

3. **Just Make a String**
   ```javascript
   const blah = "foo";
   ```
   - **Description**: This test case benchmarks the performance of simply assigning a string to a variable without any regex operation.
   - **Pros**: This approach is the fastest due to the absence of any regex compilation or searching—it's merely an assignment operation.
   - **Cons**: While this represents a baseline, it does not involve any complexity, hence it won’t provide insights into performance impacts of regex specifically.

### Benchmark Results Interpretation
The results of the benchmark show the number of executions per second for each test case:

- **Just Make a String**: 167,660,256 executions/second
- **Use Existing Regex**: 14,546,226 executions/second
- **Instantiate New Regex**: 14,204,612 executions/second

From these results, it is evident that instantiating a new regex incurs a significant performance penalty compared to using an existing regex. The cost of regex compilation is substantial, particularly when the regex is invoked frequently.

### Other Considerations
- **Performance Implications**: In performance-sensitive applications where regex is utilized heavily, developers should prefer pre-compiling their patterns and reusing them to enhance application efficiency and responsiveness.
- **Alternatives**: An alternative to using regex for certain string operations could involve native JavaScript string methods such as `.split()`, `.indexOf()`, or string manipulation functions. These methods can be faster for simpler operations as they bypass the complexity of regex. Additionally, TypeScript or newer JavaScript features (like optional chaining) can enhance code readability, although they may not directly influence performance.

### Conclusion
This benchmark sheds light on the efficiency differences between various regex approaches in JavaScript. It highlights the importance of considering both the performance implications of regex and the context in which different methods are utilized, pointing towards best practices for efficient coding in performance-critical applications.

Related benchmarks:

how fast is regex2? (version: 1)

Comparing performance of: instantiate new regex vs use existing regex vs just make a string

Created: one month ago by: Guest

Jump to the latest result

instantiate new regex

use existing regex

just make a string

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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