Benchmark: regex full match vs regex negated vs parseInt string test

HTML Preparation code:

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

Script Preparation code:

const testString = "1234567890"

const regexFullMatch = /^\d+$/
const regexNegated = /[^\d]/

Tests:

regex full match check
const value = regexFullMatch.test(testString)
parseInt check
const value = Number.isNaN(parseInt(testString, 10))
regex negated check
const value = regexNegated.test(testString)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regex full match check
parseInt check
regex negated check

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:144.0) Gecko/20100101 Firefox/144.0

Browser/OS: Firefox 144 on Linux

View result in a separate tab

parseInt check

2305.3M/s

regex negated check

51.2M/s

regex full match check

49.6M/s

View exact numbers

Test name	Executions per second
✓ parseInt check	2,305,327,872 Ops/sec
regex negated check	51,193,584 Ops/sec
regex full match check	49,575,976 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark provided tests the performance of three different methods for validating whether a string purely contains digits: using a full regular expression match, using a negated regular expression, and using `parseInt`. Each test case evaluates a different approach to ascertain the string's content.

### Test Cases Compared

1. **Regex Full Match Check**
   - **Expression**: `const value = regexFullMatch.test(testString)`
   - **Description**: This test uses a regular expression that checks if the entire string consists of digits (`/^\d+$/`).
   - **Pros**:
     - Clear intent as it directly checks for a full match against the pattern.
     - Easy to understand and modify for different matching patterns.
   - **Cons**:
     - Can be slower than pure numerical checks for longer strings due to overhead from regular expression processing.
  
2. **parseInt Check**
   - **Expression**: `const value = Number.isNaN(parseInt(testString, 10))`
   - **Description**: This method attempts to convert the string into an integer and checks if it results in `NaN` (not a number). If `parseInt` successfully parses the string to an integer, it returns that number; otherwise, it returns `NaN`.
   - **Pros**:
     - Generally faster than regex match since `parseInt` is a built-in function optimized for numerical parsing.
     - Effective for checking whole numbers without needing to form complex patterns.
   - **Cons**:
     - May lead to false positives if strings contain valid numbers but are formatted incorrectly (e.g., whitespace or delimiters).
     - Not as transparent for the goal of checking against specific character types.

3. **Regex Negated Check**
   - **Expression**: `const value = regexNegated.test(testString)`
   - **Description**: This test uses a negated regular expression (`/[^\\d]/`) to check for any non-digit characters in the string.
   - **Pros**:
     - More expressive in verifying the absence of unwanted characters.
     - Can be useful if you need to know that the string is either valid or invalid based on specific characters.
   - **Cons**:
     - Slower than other approaches due to regex overhead. 
     - Requires careful keeping of the negated logic which may introduce complexity.

### Benchmark Results Overview

- The results indicate that `parseInt` performed significantly faster than both regex tests, with an execution rate of approximately 2.3 billion executions per second compared to ~51 million for the negated regex and ~49 million for the full match regex. This shows a substantial performance advantage for numerical parsing via `parseInt`.

### Summary of Alternatives and Considerations

1. **String Methods**: One may also consider using built-in string methods, like `String.prototype.match()`, to return an array of matches for digit checks, but this would also involve regex and potentially bear the same performance overhead.

2. **Custom Iterative Checks**: For absolute performance, looping through the string characters and checking if each character is a digit using a simple comparison may yield better performance in very performance-critical cases.

3. **Use Cases**:
   - If clarity is necessary in understanding the code's intent, regex can be beneficial.
   - For performance-critical scenarios where numerous checks are required, leveraging `parseInt` or custom methods may be more suitable.

In general, the choice between these approaches will depend on the specific needs of the application, balancing between readability, maintainability, and performance.

regex full match vs regex negated vs parseInt string test (version: 1)

Comparing performance of: `regex full match check vs parseInt check vs regex negated check`

Created: 10 months ago by: Guest

Go to the latest result

regex full match check

parseInt check

regex negated check

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

regex full match vs regex negated vs parseInt string test (version: 1)

Comparing performance of: regex full match check vs parseInt check vs regex negated check

Created: 10 months ago by: Guest

Go to the latest result

regex full match check

parseInt check

regex negated check

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `regex full match check vs parseInt check vs regex negated check`