Benchmark: Regex vs For loop [1-9]|X

Script Preparation code:

var dataPool = ["1234", "1X34", "0123", "12x4"];
var testStr = dataPool[Math.floor(Math.random() * dataPool.length)];
var mwcRegex = /^(?:(?:1|X)(?=2|X|$))(?:(?:2|X)(?=3|X|$))?(?:(?:3|X)(?=4|X|$))?(?:(?:4|X)(?=5|X|$))?(?:(?:5|X)(?=6|X|$))?(?:(?:6|X)(?=7|X|$))?(?:(?:7|X)(?=8|X|$))?(?:(?:8|X)(?=9|X|$))?(?:(?:9|X)$)?$/;

Tests:

Regex and Loop
let isValid = true; for (let i = 0; i < testStr.length; i++) { let code = testStr.charAt(i); let regStr = `(${i+1}|X)`; const regEx = new RegExp(regStr); if(regEx.test(code) === false){ isValid = false; break; } } return isValid;
For loop, ParseInt
let isValid = true; for (let i = 0; i < testStr.length; i++) { let code = testStr.charAt(i); if (code === "X"){ } else{ let codeValue = parseInt(code, 10); if(codeValue !== i+1){ isValid = false; break; } } } return isValid;
For loop with switch case
let isValid = true; for (let i = 0; i < testStr.length; i++) { let char = testStr.charAt(i); switch (true) { case char === 'X': break; case parseInt(char, 10) === i + 1: break; default: isValid = false; } } return isValid;
For loop, toString
let isValid = true; for (let i = 0; i < testStr.length; i++) { let code = testStr.charAt(i); if (code === "X"){ } else{ if(code !== (i+1).toString()){ isValid = false; break; } } } return isValid;
Pure Regex
return mwcRegex.test(testStr);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Regex and Loop
For loop, ParseInt
For loop with switch case
For loop, toString
Pure Regex

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark definition json and individual test cases are used to compare different approaches for validating whether each character in the input string `testStr` matches a specific pattern.

**Test Cases**

There are 5 test cases:

1. **Regex vs For loop [1-9]|X**: This test case compares the performance of using a regular expression (`mwcRegex`) with a for loop to validate if each character in `testStr` matches either the digit `i+1` or the letter `X`.
2. **For loop, ParseInt**: This test case uses a for loop and attempts to parse the character `code` as an integer using `parseInt(code, 10)`. If the parsed value does not match `i+1`, the validation fails.
3. **For loop with switch case**: Similar to the previous test case, but instead of parsing the character as an integer, it uses a switch statement to check if the character is equal to 'X' or matches the digit `i+1`.
4. **For loop, toString**: This test case uses a for loop and checks if the character `code` is not equal to `(i+1).toString()`. If they are equal, validation fails.
5. **Pure Regex**: This test case simply uses the regular expression (`mwcRegex`) to validate if each character in `testStr` matches the pattern.

**Comparison**

The comparison between these approaches can be summarized as follows:

* **Regular expressions (Regex)**: The most efficient approach, especially for complex patterns like this one. Regular expressions are optimized by browsers and are generally faster than JavaScript loops.
* **For loop with switch statement**: This approach is slower than Regex because it involves iterating over each character in the string and checking a condition for each iteration. However, it's still a viable option if you need more control over the validation process.
* **For loop with parseInt**: This approach is also slower than Regex due to the additional overhead of parsing the character as an integer. However, it's a simple and straightforward way to implement this type of validation.
* **For loop with toString comparison**: This approach is similar to the previous one but uses string comparison instead of integer comparison.

**Pros and Cons**

* **Regex**:
	+ Pros: Most efficient, flexible, and powerful for complex patterns.
	+ Cons: May be slower than other approaches for simple patterns.
* **For loop with switch statement**:
	+ Pros: More control over the validation process, can be faster for large inputs.
	+ Cons: Slower than Regex due to iteration overhead.
* **For loop with parseInt**:
	+ Pros: Simple and straightforward implementation.
	+ Cons: Slower than Regex due to parsing overhead.
* **For loop with toString comparison**:
	+ Pros: Similar performance characteristics to the previous approach.
	+ Cons: May be slower than other approaches due to string comparison overhead.

**Browser Performance**

The provided benchmark results show that the browser performance varies depending on the test case:

* **Pure Regex**: The fastest execution time, indicating that the browser is optimized for regular expressions.
* **For loop, toString**: Slightly slower than the previous two approaches, but still relatively fast.
* **For loop with switch statement**: Slightly slower due to iteration overhead.
* **For loop with parseInt**: Slower than other approaches due to parsing overhead.

In summary, the choice of approach depends on your specific use case and performance requirements. If you need to validate complex patterns, Regex is likely the best option. For simple patterns or cases where control over the validation process is important, the for loop approaches may be suitable.

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 12; M2101K7BNY) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 107 on Android

View result in a separate tab

Test name	Executions per second
Regex and Loop	146287.3 Ops/sec
For loop, ParseInt	256911.1 Ops/sec
For loop with switch case	247614.2 Ops/sec
For loop, toString	457468.1 Ops/sec
Pure Regex	1837244.6 Ops/sec

Related benchmarks:

Regex vs For loop [1-9]|X (version: 11)

Comparing performance of: Regex and Loop vs For loop, ParseInt vs For loop with switch case vs For loop, toString vs Pure Regex

Created: 2 years ago by: Registered User

Jump to the latest result

Regex and Loop

For loop, ParseInt

For loop with switch case

For loop, toString

Pure Regex

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):