Benchmark: isUpperCase - MeasureThat.net

Tests:

char code
var isUpperCase = c => 'A' <= c && c <= 'Z'; for(c = 0; c < 128; c++) { isUpperCase(String.fromCharCode(c)); }
regex
var isUpperCase = c => /[A-Z]/.test(c); for(c = 0; c < 128; c++) { isUpperCase(String.fromCharCode(c)); }
toLowerCase
var isUpperCase = c => c !== c.toLowerCase(); for(c = 0; c < 128; c++) { isUpperCase(String.fromCharCode(c)); }
char code 2
var isUpperCase = c => { d = c.charCodeAt(); return 64 < d && d < 91; } for(c = 0; c < 128; c++) { isUpperCase(String.fromCharCode(c)); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
char code
regex
toLowerCase
char code 2

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and its various aspects for you.

**Benchmark Definition**
The benchmark is defined by a JSON object with basic metadata:

*   `Name`: A unique name for the benchmark, "isUpperCase".
*   `Description`: No description is provided in this case.
*   `Script Preparation Code`: An empty string, indicating no custom code needs to be run before running the test.
*   `Html Preparation Code`: Another empty string, suggesting that no HTML-related setup is necessary.

**Individual Test Cases**
There are four distinct test cases within the benchmark:

1.  **"char code"`**: This case tests the speed of comparing a character's ASCII value directly against other ASCII values in a range (0-127). The comparison function `isUpperCase` checks if the ASCII value falls between 'A' and 'Z'.
2.  **"regex"`**: In this test, the `isUpperCase` function uses regular expressions to match characters that are uppercase. The regular expression `/[A-Z]/` matches any character that is a capital letter.
3.  **"toLowerCase"`**: This case tests the speed of converting a character's ASCII value to lowercase and then comparing it with itself, essentially checking if the original character was uppercase. A comparison function `isUpperCase` checks for this equivalence.
4.  **"char code 2"`**: Similar to "char code", but an additional variable is introduced that stores the character's ASCII value.

**Comparison of Options**
Let's examine each option and their pros and cons:

*   **Direct Comparison (`'A' <= c && c <= 'Z'`)**:
    *   Pros: Simple, straightforward approach.
    *   Cons: May be slower than other methods due to repeated comparisons for all 128 ASCII values.
*   **Regular Expressions (`/[A-Z]/.test(c)`)**:
    *   Pros: Efficient and concise way to match uppercase characters.
    *   Cons: May have performance issues if the regex engine is slow or not optimized for speed.
*   **ASCII Value Comparison with `toLowerCase` (`c !== c.toLowerCase()`)**:
    *   Pros: Simple, fast approach that leverages JavaScript's built-in functionality for case conversion.
    *   Cons: Not directly testing the ASCII values in the range as intended by other test cases.
*   **Custom Calculation with ASCII Value (`64 < d && d < 91`)**:
    *   Pros: Direct comparison of ASCII values within a specific range, potentially more efficient than others for large ranges.
    *   Cons: May have performance issues if the calculation is slow or not optimized.

**Libraries and Special Features**
There are no external libraries used in these benchmarks. However, JavaScript's built-in functions like `String.fromCharCode` and `toLowerCase` are utilized in each test case.

Special features of JavaScript, such as closures (as seen in `c => 'A' <= c && c <= 'Z';`) or regex patterns (`/[A-Z]/`), are used within these benchmarks. These are inherent capabilities of the language itself rather than external libraries.

**Alternatives**
If you're looking to benchmark alternative approaches for string case comparison, some potential alternatives could include:

*   Using native browser APIs (e.g., `Intl.CaseFormat`) if available.
*   Implementing custom case conversion functions or algorithms that might offer better performance for specific use cases.
*   Comparing character codes directly in assembly language (if you're familiar with low-level programming) for extreme optimization.

Keep in mind that optimizing string comparison operations usually involves understanding the trade-offs between readability, maintainability, and raw performance.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36

Browser/OS: Chrome 92 on Windows

View result in a separate tab

Test name	Executions per second
char code	10254.4 Ops/sec
regex	9718.0 Ops/sec
toLowerCase	10237.1 Ops/sec
char code 2	6688.7 Ops/sec

Related benchmarks:

isUpperCase (version: 0)

Comparing performance of: char code vs regex vs toLowerCase vs char code 2

Created: 7 years ago by: Guest

Jump to the latest result

char code

regex

toLowerCase

char code 2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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