Benchmark: En-To-Em Dash Regex

Script Preparation code:

const testString = "This – is – a –test –string – with – multiple – instances– of–the – pattern – and – some – variations – like–this –and this– ";
const regex1 = /(?<= )–(?= )|(?<! )– (?! )| –(?<! ) ?/g;
const regex2 = / (?=–)–? ?|– /g;
const regex3 = /(?<= )–(?! )|–(?= )|(?<! )– (?! )/g;
const regex4step1 = / +– +/g; // Remove cases with spaces on both sides
const regex4step2 = / +–|– +/g; // Remove extra spaces
const regex5 = / – | –|– /g;
const regex6 = / – ?|– /g;

Tests:

Option 1 (Lookarounds)
testString.replace(regex1, "—");
Option 2 (Simple Lookaround)
testString.replace(regex2, "—");
Option 3 (Clever)
testString.replace(regex3, "$1—");
Option 4 (Two-Pass)
testString.replace(regex4step1, " – ").replace(regex4step2, "—");
Option 5 (Normal)
testString.replace(regex5, "—");
Option 6 (I Am Dumb)
testString.replace(regex6, "—");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Option 1 (Lookarounds)
Option 2 (Simple Lookaround)
Option 3 (Clever)
Option 4 (Two-Pass)
Option 5 (Normal)
Option 6 (I Am Dumb)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
Option 1 (Lookarounds)	548631.0 Ops/sec
Option 2 (Simple Lookaround)	953050.9 Ops/sec
Option 3 (Clever)	481046.8 Ops/sec
Option 4 (Two-Pass)	401504.5 Ops/sec
Option 5 (Normal)	1029438.0 Ops/sec
Option 6 (I Am Dumb)	1010524.4 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark you provided is designed to test different regular expression approaches for replacing en dashes (`–`) within a specific test string in JavaScript. Below is an explanation of each option tested in the benchmark, along with their pros and cons, and other considerations.

### Test Options Explained:

1. **Option 1 (Lookarounds)**
   ```javascript
   testString.replace(regex1, "—");
   ```
   - **Regex**: `/(?<= )–(?= )|(?<! )– (?! )| –(?<! ) ?/g`
   - **Purpose**: This regex uses lookbehind and lookahead assertions to match en dashes that are surrounded by spaces, as well as those that are at the beginning or end of a string.
   - **Pros**: More precise matching; avoids modifying dashes not surrounded by spaces.
   - **Cons**: Lookarounds can be computationally expensive and may result in slower performance.

2. **Option 2 (Simple Lookaround)**
   ```javascript
   testString.replace(regex2, "—");
   ```
   - **Regex**: `/ (?=–)–? ?|– /g`
   - **Purpose**: A simpler regex that matches en dashes directly followed or preceded by spaces.
   - **Pros**: Simpler pattern, potentially faster execution due to less complexity.
   - **Cons**: May not handle all edge cases as well as more complex patterns.

3. **Option 3 (Clever)**
   ```javascript
   testString.replace(regex3, "$1—");
   ```
   - **Regex**: `/(?<= )–(?! )|–(?= )|(?<! )– (?! )/g`
   - **Purpose**: This regex aims to capture en dashes through a clever combination of lookarounds.
   - **Pros**: Attempts to increase the efficiency of matching by being selective.
   - **Cons**: Complexity could lead to lower readability and maintainability.

4. **Option 4 (Two-Pass)**
   ```javascript
   testString.replace(regex4step1, " – ").replace(regex4step2, "—");
   ```
   - **Regexes**: 
     - Step 1: `/ +– +/g` (removes cases with spaces on both sides)
     - Step 2: `/ +–|– +/g` (removes extra spaces)
   - **Purpose**: Involves an initial formatting step to adjust spacing before replacing.
   - **Pros**: Very clear approach by splitting into two methods; may be easier to understand.
   - **Cons**: Slower execution due to multiple passes over the string.

5. **Option 5 (Normal)**
   ```javascript
   testString.replace(regex5, "—");
   ```
   - **Regex**: `/ – | –|– /g`
   - **Purpose**: A straightforward regex that matches various representations of the en dash, replacing them with a consistent character.
   - **Pros**: Direct implementation; easy to follow.
   - **Cons**: Less precise, may overshoot in terms of replacement (risk of changing unintended occurrences).

6. **Option 6 (I Am Dumb)**
   ```javascript
   testString.replace(regex6, "—");
   ```
   - **Regex**: `/ – ?|– /g`
   - **Purpose**: This regex has minimal matching criteria and is, as the name suggests, a less intelligent approach to en dash detection and replacement.
   - **Pros**: Extremely simple and likely fast due to its simplicity.
   - **Cons**: High risk of incorrect replacements, less careful than other options.

### Benchmark Results Overview

- **Executions per Second**: The performance of each option is measured in terms of how many executions can be completed in one second.
- Based on the results:
  - **Best Performing Option**: **Option 5 (Normal)** had the highest execution rate, indicating it was the fastest in this benchmark.
  - **Least Performing Option**: **Option 4 (Two-Pass)** exhibits the slowest execution, highlighting a significant drawback of multi-pass regex processing compared to more direct approaches.

### Other Considerations and Alternatives

- **Library Options**: While not used in the benchmark directly, libraries like **Lodash** or **Ramda** may simplify or enhance string manipulation but would come with their trade-offs (e.g., larger bundle sizes).
- **Alternatives**: If precise control over string replacement is needed, alternatives include:
  - **Custom parsing logic**: Manual parsing could be more efficient for very specific cases.
  - **Using external libraries** specifically designed for string processing which include built-in functions for dash replacements could provide more abstracted solutions.
  
This benchmark showcases how different regex approaches can drastically alter performance in JavaScript, with a balance between accuracy, complexity, and speed needing to be considered by software engineers when choosing their strategies for string manipulation.

Related benchmarks:

En-To-Em Dash Regex (version: 9)

Comparing performance of: Option 1 (Lookarounds) vs Option 2 (Simple Lookaround) vs Option 3 (Clever) vs Option 4 (Two-Pass) vs Option 5 (Normal) vs Option 6 (I Am Dumb)

Created: one month ago by: Registered User

Jump to the latest result

Option 1 (Lookarounds)

Option 2 (Simple Lookaround)

Option 3 (Clever)

Option 4 (Two-Pass)

Option 5 (Normal)

Option 6 (I Am Dumb)

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):