Benchmark: how fast is regex3?

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 regex
const newOne = /[.*+?^${}()|[\]\\]/g;
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 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/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
instantiate new regex	15960742.0 Ops/sec
use existing regex	13052096.0 Ops/sec
just make a regex	168466000.0 Ops/sec
just make a string	155052112.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark provided is focused on evaluating the performance of different approaches to using regular expressions (regex) in JavaScript. Regular expressions are sequences of characters that form a search pattern, primarily used for string matching. This benchmark specifically examines the performance regarding regex instantiation and usage.

### Test Cases Overview:
1. **Just Make a Regex**
   - **Benchmark Definition**: `const newOne = /[.*+?^${}()|[\\]\\\\]/g;`
   - **Test Name**: "just make a regex"
   - **Description**: This test simply creates a new regex object.
   - **Execution Speed**: Fastest performance observed.

2. **Just Make a String**
   - **Benchmark Definition**: `const blah = "foo";`
   - **Test Name**: "just make a string"
   - **Description**: This test creates a simple string variable, serving as a base for regex operations.
   - **Execution Speed**: Similar performance to regex creation; shows that basic string operations are lightweight.

3. **Instantiate New Regex**
   - **Benchmark Definition**: `const blah = "whatever"; const r = blah.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&");`
   - **Test Name**: "instantiate new regex"
   - **Description**: Here, a new regex is instantiated for each test, which involves compiling the regex pattern during each run.
   - **Execution Speed**: Notably slower compared to simply creating a regex.

4. **Use Existing Regex**
   - **Benchmark Definition**: `const blah = "whatever"; const r = blah.replace(prepared, "\\$&");`
   - **Test Name**: "use existing regex"
   - **Description**: This test utilizes the regex created in the preparation step (`prepared`) rather than instantiating a new regex on each invocation.
   - **Execution Speed**: Slowest compared to direct regex creation, since it requires a match and replace operation.

### Pros and Cons of Different Approaches:
- **Just Make a Regex**:
  - **Pros**: Quick instantiation of regex without the overhead of repeated computations or modifications.
  - **Cons**: Limited usage since it creates a regex without applying it.
  
- **Just Make a String**:
  - **Pros**: Extremely lightweight and quick; foundational step that doesn’t involve regex complexity.
  - **Cons**: Cannot evaluate performance of regex directly.

- **Instantiate New Regex**:
  - **Pros**: Ensures fresh regex instances for each evaluation. Useful when different patterns are required for operations.
  - **Cons**: Performance overhead due to repeated compilation of the regex for every execution, making it inefficient for scenarios where the same pattern is reused.

- **Use Existing Regex**:
  - **Pros**: Reduces overhead by reusing an already compiled regex, which is often more efficient for multiple uses of the same pattern.
  - **Cons**: Still involves the processing overhead of a match and replace operation, leading to slower overall performance compared to direct regex creation.

### Library Context:
In this benchmark, the JavaScript Regex engine itself is being utilized, which is a built-in feature of the JavaScript language. No external libraries are involved; thus, this benchmarking purely evaluates the regex capabilities natively provided by the language.

### Summary and Alternatives:
The current benchmark results indicate that simply creating regex patterns or strings can be significantly faster than repeated instantiation or use of regex for replacements. Software engineers should be mindful of performance implications when deciding whether to instantiate a new regex or use an existing one.

**Alternatives** to the approaches evaluated may include:
- **Caching Regex Patterns**: Create a single regex pattern and cache it for reuse in multiple operations to minimize instantiation overhead.
- **Using String Methods**: Depending on the performance requirements, using string methods like `.includes()` or `.indexOf()` might offer better performance if complex pattern matching is unnecessary.
- **Employing Libraries**: For advanced regex operations, libraries like XRegExp can be utilized to offer more flexible regex handling, though they may introduce their own set of performance considerations.

Engineers should choose the appropriate method based on specific performance needs, complexity requirements, and the nature of string manipulation they are implementing.

Related benchmarks:

how fast is regex3? (version: 1)

Comparing performance of: instantiate new regex vs use existing regex vs just make a 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 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):