Benchmark: Alphanumeric String

HTML Preparation code:

var string = "isAlphaNumeric091";

Script Preparation code:

var string = "isAlphaNumeric091";

Tests:

Regex
/^[a-z0-9]+$/i.test(string)
charCodeAt
function isAlphaNumeric(str) { for (let i = 0; i < str.length; i++) { let code = str.charCodeAt(i) if (!(code > 47 && code < 58) && // numeric (0-9) !(code > 64 && code < 91) && // upper alpha (A-Z) !(code > 96 && code < 123)) { // lower alpha (a-z) return false } } return true } isAlphaNumeric(string)

Historical Performance Data aggregated from 42 community runs

Desktop Results:

Chrome 36 runs

charCodeAt

10.1M/s

Regex

9.7M/s

View exact numbers

✓ charCodeAt: 10,121,228 ops/sec
• Regex : 9,671,890 ops/sec

Firefox 6 runs

Regex

10.4M/s

charCodeAt

7.3M/s

Fastest: Regex (1.4x faster)

View exact numbers

✓ Regex : 10,444,297 ops/sec
• charCodeAt: 7,293,570 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Regex
charCodeAt

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 7 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:146.0) Gecko/20100101 Firefox/146.0

Browser/OS: Firefox 146 on Windows

View result in a separate tab

Regex

55.6M/s

charCodeAt

30.5M/s

View exact numbers

Test name	Executions per second
✓ Regex	55,639,524 Ops/sec
charCodeAt	30,533,926 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested, compared options, pros and cons, and other considerations.

**Benchmark Definition**

The benchmark definition represents a simple test that checks if a given string only contains alpha-numeric characters (letters and numbers). The script preparation code creates a sample string "isAlphaNumeric091" for testing purposes.

**Test Cases**

There are two individual test cases:

1. **Regex Test Case**
	* Benchmark Definition: `/^[a-z0-9]+$/i.test(string)`
	* This test case uses a regular expression (regex) to check if the input string only contains alphanumeric characters.
2. **charCodeAt Test Case**
	* Benchmark Definition: `function isAlphaNumeric(str) {\r\n    for (let i = 0; i < str.length; i++) {\r\n        let code = str.charCodeAt(i)\r\n        if (!(code > 47 && code < 58) && // numeric (0-9)\r\n            !(code > 64 && code < 91) && // upper alpha (A-Z)\r\n            !(code > 96 && code < 123)) { // lower alpha (a-z)\r\n            return false\r\n        }\r\n    }\r\n    return true\r\n}\r\n\r\nisAlphaNumeric(string)`
	* This test case uses a custom JavaScript function `isAlphaNumeric` that checks each character in the input string using `charCodeAt`. If any non-alphanumeric character is found, the function returns `false`.
3. **Purpose**

Both test cases aim to measure the performance of the browser when running these specific tests.

**Options Compared**

The two test cases compare:

* Regex vs Custom `charCodeAt` implementation
* Performance difference between using a built-in regex engine and a custom implementation

**Pros and Cons**

1. **Regex Test Case**
	* Pros:
		+ Widely supported by most browsers
		+ Concise and efficient code
	* Cons:
		+ May be slower due to the overhead of the regex engine
		+ Limited control over the matching process
2. **charCodeAt Test Case**
	* Pros:
		+ More control over the matching process
		+ Potential for better performance, as it avoids regex engine overhead
	* Cons:
		+ Requires manual implementation and maintenance
		+ May be less concise than a regex solution

**Other Considerations**

* **Library usage**: Neither test case uses an external library. The regex test case relies on the browser's built-in regex engine, while the custom `charCodeAt` implementation is self-contained.
* **JS feature or syntax**: The custom `charCodeAt` implementation demonstrates the use of a specific JavaScript feature: iterating over a string and checking character codes.
* **Browser variations**: It's essential to note that these tests are likely designed to run on different browsers, which may have varying levels of support for regex engines or performance characteristics.

**Alternatives**

If you were to rewrite this benchmark with alternative approaches:

1. Use a regular expression engine from a third-party library (e.g., `regexjs`) for more control and potential better performance.
2. Implement a custom string matching algorithm using bitwise operations, character flags, or other low-level techniques.
3. Use a different testing framework or tool that provides built-in support for regex or custom string matching.

Keep in mind that these alternatives may introduce additional complexity, overhead, or platform dependencies, which should be carefully considered when choosing an approach.

Alphanumeric String (version: 0)

Check if a string only contains alpha-numeric characters.

Comparing performance of: `Regex vs charCodeAt`

Created: 4 years ago by: Registered User

Go to the latest result

Regex

charCodeAt

Historical Performance Data aggregated from 42 community runs

Desktop Results:

Chrome 36 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Alphanumeric String (version: 0)

Check if a string only contains alpha-numeric characters.

Comparing performance of: Regex vs charCodeAt

Created: 4 years ago by: Registered User

Go to the latest result

Regex

charCodeAt

Historical Performance Data aggregated from 42 community runs

Desktop Results:

Chrome 36 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `Regex vs charCodeAt`