Benchmark: regex vs bigint - MeasureThat.net

Script Preparation code:

// Test description: Comparing regex validation vs try-catch with BigInt for numeric string validation

// Setup
const validTokenId = "12345678901234567890"; // Valid numeric string
const invalidTokenId = "123abc456"; // Invalid numeric string containing letters

// Test function for regex validation
function validateWithRegex(tokenId) {
    return /^\d+$/.test(tokenId);
}

// Test function for try-catch validation
function validateWithTryCatch(tokenId) {
    try {
        BigInt(tokenId);
        return true;
    } catch {
        return false;
    }
}
      
      // Benchmark suite
suite('String Numeric Validation', function() {
    // Regex with valid input
    benchmark('Regex validation - Valid input', function() {
        return validateWithRegex(validTokenId);
    });

    // Regex with invalid input
    benchmark('Regex validation - Invalid input', function() {
        return validateWithRegex(invalidTokenId);
    });

    // Try-catch with valid input
    benchmark('Try-catch validation - Valid input', function() {
        return validateWithTryCatch(validTokenId);
    });

    // Try-catch with invalid input
    benchmark('Try-catch validation - Invalid input', function() {
        return validateWithTryCatch(invalidTokenId);
    });
});

Tests:

TestRegex validation - Valid input
validateWithRegex(validTokenId)
Regex validation - Invalid input
validateWithRegex(invalidTokenId)
Try-catch validation - Valid input
validateWithTryCatch(validTokenId)
Try-catch validation - Invalid input
validateWithTryCatch(invalidTokenId)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
TestRegex validation - Valid input
Regex validation - Invalid input
Try-catch validation - Valid input
Try-catch validation - Invalid input

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/108.0.0.0 Safari/537.36

Browser/OS: Chrome 108 on Windows

View result in a separate tab

Test name	Executions per second
TestRegex validation - Valid input	26010314.0 Ops/sec
Regex validation - Invalid input	43248424.0 Ops/sec
Try-catch validation - Valid input	11689074.0 Ops/sec
Try-catch validation - Invalid input	102001.5 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark provided compares two methods for validating numeric strings in JavaScript: using a regular expression (regex) and using a try-catch block combined with the `BigInt` constructor. It measures how well each method performs under different input conditions (valid and invalid numeric strings).

### Methods Under Comparison

1. **Regex Validation**:
   - **Function**: `validateWithRegex(tokenId)` uses the regex pattern `/^\d+$/`, which tests if the input string contains only digits from start to end.
   - **Input**: 
     - `validTokenId`: a string that represents a valid numeric value `"12345678901234567890"`.
     - `invalidTokenId`: a string containing non-numeric characters `"123abc456"`.

2. **Try-Catch Validation**:
   - **Function**: `validateWithTryCatch(tokenId)` attempts to create a `BigInt` from the input string. If the string is not a valid numeric value, it throws an error, which is caught in the catch block.
   - **Use of `BigInt`**: This special JavaScript feature allows for the representation of integers larger than `Number.MAX_SAFE_INTEGER` (2^53 - 1). Using `BigInt` is significant for applications requiring arithmetic with very large integers.

### Test Cases

The benchmark includes four test cases:

1. **Regex validation with valid input**: Measures effectiveness and performance when the input string is valid.
   - Expected behavior: Returns `true`.

2. **Regex validation with invalid input**: Tests how the regex behaves with non-numeric input.
   - Expected behavior: Returns `false`.

3. **Try-catch validation with valid input**: Assesses performance when `BigInt` should successfully convert the valid numeric string.
   - Expected behavior: Returns `true`.

4. **Try-catch validation with invalid input**: Tests how `BigInt` behaves with invalid numeric strings.
   - Expected behavior: Returns `false`.

### Performance Results

The benchmark results show the number of executions per second for each test case:

- **Regex Validation - Invalid Input**: 75,816,416 executions per second.
- **Regex Validation - Valid Input**: 57,875,340 executions per second.
- **Try-Catch Validation - Valid Input**: 27,872,944 executions per second.
- **Try-Catch Validation - Invalid Input**: 373,192.4375 executions per second.

### Analysis of Pros and Cons

**Regex Validation**:
- **Pros**:
  - Extremely fast for both valid and invalid cases.
  - Straightforward to implement and understand.
  
- **Cons**:
  - Limited to simple patterns; may not cover complex validations if needed.

**Try-Catch Validation**:
- **Pros**:
  - Useful for validating very large numbers that exceed the regular number range.
  - Can handle a wide range of numeric inputs beyond simple string checks (e.g., scientific notation).

- **Cons**:
  - Significantly slower performance, particularly for invalid inputs; the overhead of exception handling can be costly.
  - If used excessively in performance-critical applications, it could lead to inefficiencies.

### Alternatives

- **TypeScript or Runtime-Type-checking Libraries**: Instead of using raw `try-catch` or regex, libraries like `zod` or `Joi` can offer more sophisticated validation, albeit with potential performance costs.
  
- **Native Number Parsing**: Utilizing `parseFloat` or `parseInt` could also be a valid option, albeit they have limitations (e.g., they do not handle large integers as accurately as `BigInt`).

### Conclusion

The benchmark effectively illustrates the performance differences between using regex and try-catch with `BigInt` for validating numeric strings. While regex is faster and simple for basic validation, `BigInt` provides robust handling for large integers at the cost of performance, particularly in an invalid input scenario. Understanding these trade-offs allows developers to choose the most appropriate method depending on their application's requirements.

Related benchmarks:

regex vs bigint (version: 1)

Comparing performance of: TestRegex validation - Valid input vs Regex validation - Invalid input vs Try-catch validation - Valid input vs Try-catch validation - Invalid input

Created: one month ago by: Guest

Jump to the latest result

TestRegex validation - Valid input

Regex validation - Invalid input

Try-catch validation - Valid input

Try-catch validation - Invalid input

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