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 = 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 < eng_str.length; i++) { const code = 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

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

LLMs can make mistakes. Check important info.

The provided JSON represents a benchmark test created on MeasureThat.net, which compares the performance of three approaches to validate whether a string contains only English letters and digits.

**Benchmark Definition**

The benchmark definition is as follows:

*   `cycle`: A loop that iterates over each character in the input strings (`eng_str` or `rus_str`) and checks if it's an English letter or digit using the `charCodeAt()` method.
*   `regex`: The use of a regular expression (regex) to match the string against the pattern `^[A-Z0-9]+$`, which matches any string that starts with one or more alphanumeric characters.

**Comparison**

The benchmark compares the performance of these two approaches:

1.  **Cycle**: This approach uses a simple loop to iterate over each character in the input strings and checks if it's an English letter or digit using `charCodeAt()`.
2.  **Regex**: This approach uses a regex pattern to match the string against the expected pattern, which is more concise and expressive than the cycle approach.

**Pros and Cons**

*   **Cycle:**
    *   Pros:
        *   Simple and easy to understand.
        *   Can be optimized for specific use cases (e.g., using a `switch` statement instead of `charCodeAt()`).
    *   Cons:
        *   Can be slower than regex due to the overhead of repeated string indexing operations.
*   **Regex:**
    *   Pros:
        *   More concise and expressive than the cycle approach.
        *   Can perform multiple checks in a single operation (e.g., checking for alphanumeric characters).
    *   Cons:
        *   May be slower than the cycle approach due to the overhead of regex parsing and execution.

**Other Considerations**

*   The use of `charCodeAt()` in the cycle approach assumes that the input strings are encoded in a format that preserves Unicode code points (e.g., UTF-8). If the input strings have different encodings, the results may vary.
*   The regex pattern used in this benchmark only matches English letters and digits. To match other characters or languages, additional character classes can be added to the regex pattern.

**Library**

There is no specific library mentioned in the benchmark definition that is being used beyond JavaScript's built-in `charCodeAt()` method and `String.prototype.test()` method for the regex approach.

**Special JS Features/Syntax**

The benchmark uses JavaScript's `let` and `const` declaration keywords, which are part of the ES6 syntax. It also uses template literals (`\r\n`) to define multiline strings, which is a newer feature introduced in ECMAScript 2015.

**Other Alternatives**

There are other approaches that could be used to validate whether a string contains only English letters and digits:

1.  **Using a `RegExp` object**: Instead of using the `test()` method, you can create a regular expression pattern as an instance of `RegExp` and then use its `test()` or `exec()` methods.
2.  **Implementing a custom validation function**: You can write a custom validation function that iterates over each character in the input string and checks if it's an English letter or digit using a simple algorithm, such as checking Unicode code points.

Here is a sample implementation of the cycle approach using a `switch` statement instead of `charCodeAt()`:

```javascript
function validateString(str) {
  for (let index = 0; index < str.length; index++) {
    const charCode = String.fromCharCode(str.charCodeAt(index));
    switch (charCode) {
      case 'A':
      case 'B':
      case 'C':
      case ...
        // match uppercase letters
      default:
        return false;
    }
  }
  return true;
}
```

And here's a sample implementation of the regex approach:

```javascript
function validateString(str) {
  const regex = /^[A-Z0-9]+$/i;
  return regex.test(str);
}
```

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 YaBrowser/18.2.1.174 Yowser/2.5 Safari/537.36

Browser/OS: Yandex Browser 18 on Windows

View result in a separate tab

Test name	Executions per second
cycle eng_str	0.0 Ops/sec
cycle rus_str	0.0 Ops/sec
regex eng_str	63.1 Ops/sec
regex rus_str	63.5 Ops/sec

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: 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 28 days ago):