This benchmark compares the performance of two types of regular expressions in JavaScript: capturing and non-capturing groups. Both types of regex are commonly used for pattern matching in strings, but they serve slightly different purposes.

Benchmark Overview

Script Preparation

let string = 'hello123';
let f = /(hello|hi)123/; // Capturing regex
let n = /(?:hello|hi)123/; // Non-capturing regex

Here, the benchmark initializes a test string, string, with the value 'hello123'. It also defines two regular expressions:

1. f which uses capturing groups /(hello|hi)123/
2. n which uses non-capturing groups /(?:hello|hi)123/

Individual Test Cases

1. Capturing Test Case:

   • Definition: string.match(f)
   • Purpose: This regex captures the substring hello or hi in string. Capturing groups are useful when you need to extract and use the matched portions later.

2. Non-Capturing Test Case:

   • Definition: string.match(n)
   • Purpose: This regex behaves similarly but does not store the matching parts. Non-capturing groups are used when you want to apply a group for quantifiers or logical conditions without needing to extract the captured content.

Performance Results

The benchmark results indicate the number of executions per second for both test cases:

• Non-Capturing: 16,613,423 executions per second
• Capturing: 15,344,823 executions per second

The non-capturing regex performed faster than the capturing regex. This is generally expected, as non-capturing groups require less overhead since they do not need to store matches.

Pros and Cons

Capturing Groups

• Pros:
  • Useful when you need to extract specific parts of the matched string for further processing.
  • Can be referenced within the same regex for more complex patterns.
• Cons:
  • Performance overhead due to the need to maintain captured values.
  • Increased complexity in cases where captured values are not needed.

Non-Capturing Groups

• Pros:
  • More performant as they avoid storage for matches.
  • Simplifies regex functions where captured values are unnecessary.
• Cons:
  • Cannot reference matched substrings later in the regex execution.
  • Limited usability if specific elements need to be extracted.

Other Considerations

• In scenarios involving complex regex patterns, the performance difference can become significant, making non-capturing groups a better option when extraction is not required.
• Both regex types behave similarly in simpler patterns, so understanding when to use each type can help optimize performance and resource usage.

Alternatives

1. Using Different Regex Engines: Various JavaScript libraries offer different regex engines (like XRegExp) that may provide enhanced functionality. These libraries allow for more complex operations, such as named capturing groups, but may trade off some performance.

2. String Methods: For simple substring searches, methods like String.includes(), String.startsWith(), or String.endsWith() may provide clarity and improved performance when regular expressions are not required.

3. Custom Logic: In some use cases, manual string manipulation combined with logical conditions might outperform even optimized regex, particularly for predictable formats.

This benchmark highlights the performance characteristics of capturing vs. non-capturing regex in JavaScript, guiding engineers in their decision-making process when using regular expressions for pattern matching.