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++) { is_only_eng_letters_and_digits(eng_str); }
cycle rus_str
for (let index = 0; index < 100000; index++) { is_only_eng_letters_and_digits(rus_str); }
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: 6 years ago)

User agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36 Maxthon/5.2.1.1000

Browser/OS: Maxthon 5 on Windows 7

View result in a separate tab

Test name	Executions per second
cycle eng_str	35.8 Ops/sec
cycle rus_str	36.3 Ops/sec
regex eng_str	50.7 Ops/sec
regex rus_str	50.5 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark test created on the MeasureThat.net platform. The benchmark compares the execution performance of two approaches: using `for` loops to iterate over strings and using regular expressions (`regex`) to filter out non-alphanumeric characters.

**Test Cases**

There are four individual test cases:

1. **Cycle Eng Str**: Iterates 100,000 times over a string containing only English letters and digits.
2. **Cycle Rus Str**: Iterates 100,000 times over a string containing Russian letters (using the Cyrillic alphabet).
3. **Regex Eng Str**: Uses regular expressions to test if each character in the string is an English letter or digit.
4. **Regex Rus Str**: Similar to the previous point, but tests against the Russian alphabet.

**Approaches Compared**

The benchmark compares two approaches:

1. **For Loops (Cycle)**: Iterates over a string using traditional `for` loops, which are generally slower and more memory-intensive than other methods.
2. **Regular Expressions (Regex)**: Uses regular expressions to filter out non-alphanumeric characters, which is typically faster and more efficient.

**Pros and Cons**

**For Loops (Cycle)**

Pros:

* Easy to understand and implement
* Can be optimized for specific use cases

Cons:

* Generally slower and less efficient than other methods
* More memory-intensive due to the need to store iteration variables

**Regular Expressions (Regex)**

Pros:

* Typically faster and more efficient
* Can handle complex filtering rules with a single expression

Cons:

* Can be slower for very large datasets
* May require more processing power due to the use of regex engines

**Library Used**

The `test()` function in each benchmark definition is not explicitly stated, but it's likely that MeasureThat.net uses an internal implementation that provides a consistent and efficient way to execute JavaScript tests.

**Special JS Feature/Syntax**

There are no specific JavaScript features or syntax mentioned in the provided code. The use of regular expressions is a standard JavaScript feature, and the `for` loops are also a standard construct.

**Other Alternatives**

If you're interested in exploring alternative approaches, here are some options:

1. **Array.prototype.forEach()**: Instead of using traditional `for` loops, you can use `forEach()` to iterate over arrays.
2. **String.prototype.replace()**: You can use the `replace()` method to filter out non-alphanumeric characters from a string.
3. **Set operations**: You can use Set data structures to efficiently filter out non-alphanumeric characters.

Keep in mind that the performance benefits of these alternatives may vary depending on the specific use case and hardware.

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: 6 years ago by: Registered User

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 2 months ago):