Benchmark: cycle vs regex - MeasureThat.net

Script Preparation code:

function is_only_eng_letters_and_digits(str) {
            for (let index = 0; index < str.length; index++) {
                const code = str.charCodeAt(index);
                if (!(code >= 65 && code <= 90) && !(code >= 97 && code <= 122) && !(code >= 48 && code <= 57)) {
                    return false;
                }
            }
            return true;
}
var eng_str = "qwerty123";
var rus_str = "qwertyФЫВА123";

Tests:

cycle eng_str
for (let index = 0; index < 100000; index++) { for (let i = 0; i < eng_str.length; i++) { const code = eng_str.charCodeAt(i); if (!(code >= 65 && code <= 90) && !(code >= 97 && code <= 122) && !(code >= 48 && code <= 57)) { break; } } }
cycle rus_str
for (let index = 0; index < 100000; index++) { for (let i = 0; i < rus_str.length; i++) { const code = rus_str.charCodeAt(i); if (!(code >= 65 && code <= 90) && !(code >= 97 && code <= 122) && !(code >= 48 && code <= 57)) { break; } } }
regex eng_str
for (let index = 0; index < 100000; index++) { /^[A-Z0-9]+$/i.test(eng_str); }
regex rus_str
for (let index = 0; index < 100000; index++) { /^[A-Z0-9]+$/i.test(rus_str); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
cycle eng_str
cycle rus_str
regex eng_str
regex rus_str

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
cycle eng_str	361.4 Ops/sec
cycle rus_str	480.4 Ops/sec
regex eng_str	251.2 Ops/sec
regex rus_str	294.1 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Measuring the performance of different approaches to validate string characters is an essential task in software development.

**Benchmark Description**

The provided benchmark compares three approaches to validate if a string consists only of English letters and digits:

1. **Cycle Approach**: This approach uses nested loops to iterate through each character in the string and checks its ASCII value to determine if it falls within the valid range for English letters (65-90) and digits (48-57).
2. **Regex Approach**: This approach uses regular expressions to test if the string matches a pattern that includes only English letters and digits (`^[A-Z0-9]+$`).

**Options Compared**

The benchmark compares the following three approaches:

* Cycle Approach (using nested loops)
* Regex Approach (using regular expressions)

**Pros and Cons of Each Approach:**

1. **Cycle Approach**:
	* Pros:
		+ Can be implemented in a single loop, reducing overhead.
		+ May be faster for small strings due to fewer function calls.
	* Cons:
		+ Has higher constant factor due to the nested loops, which can lead to slower performance for larger strings.
		+ More prone to errors if the ASCII values are not correctly checked.
2. **Regex Approach**:
	* Pros:
		+ Faster and more efficient for large strings due to caching and optimized engine.
		+ Less error-prone as it uses a standardized pattern that can be tested using the `test()` method.
	* Cons:
		+ May have slower performance for small strings due to the overhead of compiling and executing the regular expression.

**Library Used**

The benchmark does not explicitly mention any library, but it is likely that the built-in JavaScript functions (`charCodeAt()`, `test()`) are used under the hood. The regex pattern `^[A-Z0-9]+$` also relies on the underlying regex engine.

**Special JS Features/Syntax**

None of the approaches use any special JavaScript features or syntax beyond standard JavaScript functions and operators.

**Other Considerations**

When choosing between these two approaches, consider the following:

* If you're working with small strings or need to validate a specific pattern, the Cycle Approach might be sufficient. However, for larger strings or more complex patterns, the Regex Approach is likely to be faster and more efficient.
* Be mindful of potential errors in the Cycle Approach due to incorrect ASCII value checks.

**Alternatives**

Some alternative approaches could include:

* **Using a dedicated string validation library**: Depending on your use case, you might want to consider using an existing library that provides optimized string validation functions.
* **Implementing a custom optimization**: If you're familiar with the underlying implementation of the JavaScript engine or regex engine, you could potentially optimize either approach for better performance.

Keep in mind that these alternatives are not mentioned in the benchmark, and their feasibility would depend on your specific use case and requirements.

Related benchmarks:

cycle vs regex (version: 0)

Comparing performance of: cycle eng_str vs cycle rus_str vs regex eng_str vs regex rus_str

Created: 7 years ago by: Guest

Jump to the latest result

cycle eng_str

cycle rus_str

regex eng_str

regex rus_str

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):