Benchmark: Regex vs Native - MeasureThat.net

HTML Preparation code:

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

Script Preparation code:

const isUserAgentToggleOnNative = (allowedUserAgents) => {
  const userAgent = typeof navigator !== "undefined" ? navigator?.userAgent : ""
  return allowedUserAgents.some(x=> userAgent.includes(x));
}

const USERNAME_PASSWORD_ALLOWED_USER_AGENTS = ["DatadogSynthetics", "k6"]

const isUserAgentToggleOnRegex = allowedUserAgents => {
  const userAgent = typeof navigator !== "undefined" ? navigator?.userAgent : ""
  const regex = new RegExp(`(${allowedUserAgents.join("|")})`)
  return regex.test(userAgent)
}

const DATADOG_SYNTHETICS_USER_AGENT = 'DatadogSynthetics',  K6_USER_AGENT = 'k6';

Tests:

Regex
/*When writing async/deferred tests, use `deferred.resolve()` to mark test as done*/ isUserAgentToggleOnRegex(USERNAME_PASSWORD_ALLOWED_USER_AGENTS)
Native
isUserAgentToggleOnNative(USERNAME_PASSWORD_ALLOWED_USER_AGENTS);
Regex with useragent having value
const navigator = { userAgent: 'k6' } isUserAgentToggleOnRegex(USERNAME_PASSWORD_ALLOWED_USER_AGENTS)
NAtive with useragent having value
const navigator = { userAgent: 'k6' } isUserAgentToggleOnNative(USERNAME_PASSWORD_ALLOWED_USER_AGENTS);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Regex
Native
Regex with useragent having value
NAtive with useragent having value

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 6 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Regex	2985979.8 Ops/sec
Native	5183315.0 Ops/sec
Regex with useragent having value	2992061.2 Ops/sec
NAtive with useragent having value	5188943.5 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 6 days ago):

LLMs can make mistakes. Check important info.

The provided benchmark tests the performance of two different methods for checking whether the user agent string matches a given set of allowed user agents. The comparison is made between a native approach that uses standard string methods and a regex-based approach that uses regular expressions.

### Test Cases Descriptions

1. **Regex**: 
   - The `isUserAgentToggleOnRegex` function uses a regular expression to check if any of the user agents in the `USERNAME_PASSWORD_ALLOWED_USER_AGENTS` array are present in the `navigator.userAgent` string.
   - In the context of the benchmark, this function is called without a specific user agent value, relying on the default `navigator.userAgent`.

2. **Native**: 
   - The `isUserAgentToggleOnNative` function checks the same condition but does so using the `includes` method on the string. It evaluates if any of the specified user agents appear in the `navigator.userAgent`.
   - The native method is tested similarly to the Regex method without specific user agent context.

3. **Regex with user agent having value**: 
   - This test specifically sets a mock `navigator.userAgent` to `k6` and then runs the regex check. The primary goal is to see how the regex performs when it’s explicitly provided with a target user agent.

4. **Native with user agent having value**: 
   - Similar to the previous test, but it calls the native method. The intention is to observe the performance of the native check utilizing a specified user agent.

### Performance Results

1. **NAtive with user agent having value**: 
   - Highest execution rate, suggesting that the native method is more efficient in this specific context when a value is explicitly provided.

2. **Native**: 
   - Still shows excellent performance but scores slightly lower than the 'Native with user agent' case. This shows consistency in the native method's speed.

3. **Regex with user agent having value**: 
   - Performance is significantly lower than the native methods, indicating that regex evaluation in this context is slower than direct string matching.

4. **Regex**: 
   - Shows the lowest execution rate. This result confirms that regex is less efficient compared to native string methods for this use case.

### Pros and Cons of Each Approach

**Regex Approach:**
- **Pros:**
  - More flexibility when pattern matching is needed, as it can handle complex matching scenarios.
- **Cons:**
  - Performance overhead, especially for simpler checks where regex is not required.
  - Increased complexity and potential for errors in pattern formation.

**Native Approach:**
- **Pros:**
  - Better performance in terms of execution speed for simple substring checks.
  - Simpler to understand and maintain without the need for regex syntax.
- **Cons:**
  - Less flexible for complex matching patterns that regex can handle easily.

### Additional Considerations

- **Performance**: The results clearly show that for simple checks like user agent validation, native string methods (e.g., `includes`) significantly outperform regex-based methods. This is critical for applications where performance is paramount and multiple validations are executed frequently.
  
- **Use Cases**: The choice between regex and native methods should depend on the specific requirements of the application. If complex matches are necessary, regex can be beneficial despite its performance drawback. However, for straightforward validations like this user agent check, the native approach is preferable.

### Alternatives

1. **String Methods**: Alternatives like `indexOf` can be utilized along with conditions to check the presence of substrings, but modern methods like `includes` are recommended for clarity.

2. **Third-party Libraries**: For complex string manipulation or parsing, libraries like Lodash may provide utility functions that enhance readability and code quality, though they will also introduce additional dependencies.

3. **Custom Implementations**: One could develop a custom search algorithm for particular matching scenarios, though this is generally not necessary for standard use cases.

By carefully considering these factors, developers can make informed decisions on which approach best suits their needs, balancing performance with maintainability.

Related benchmarks:

Regex vs Native (version: 2)

Comparing performance of: Regex vs Native vs Regex with useragent having value vs NAtive with useragent having value

Created: 6 days ago by: Registered User

Jump to the latest result

Regex

Native

Regex with useragent having value

NAtive with useragent having value

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 6 days ago):