Benchmark: Check if character is not a lowercase letter

Script Preparation code:

function regex(key) {
  return /[^a-z]/.test(key);
}

const alpha = "abcdefghijklmnopqrstuvwxyz";
function alphaIncludes(key) {
  return alpha.includes(key);
}

function charCodeBetween(key) {
  return key >= 97 && key <= 122
}

Tests:

regex
regex("s")
alphaIncludes
alphaIncludes("s")
charCodeBetween
charCodeBetween("s")

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regex
alphaIncludes
charCodeBetween

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark definition and options compared.

**Benchmark Definition:**

The benchmark is designed to test three different approaches:

1. **Regex**: Using regular expressions to check if a character is not a lowercase letter.
2. **Alphabet String Includes**: Checking if a character is included in an alphabet string ("abcdefghijklmnopqrstuvwxyz").
3. **CharCodeAt**: Using the `charCodeAt()` method to check if a character's Unicode code point falls within a specific range (97-122, which corresponds to lowercase letters).

**Options Compared:**

These three approaches are compared to determine their performance characteristics.

* **Pros and Cons:**
	+ Regex:
		- Pros: Regular expressions can be powerful pattern-matching tools.
		- Cons: They can be slow due to the complexity of parsing and matching patterns.
	+ Alphabet String Includes:
		- Pros: This approach is simple and fast, as it only requires a single array lookup.
		- Cons: It may not be suitable for larger alphabet strings or more complex checks.
	+ CharCodeAt:
		- Pros: This approach can be efficient for Unicode code point operations.
		- Cons: It relies on the `charCodeAt()` method's performance, which may vary depending on the browser and environment.

**Library Usage:**

The benchmark uses the following library:

* None explicitly mentioned. However, it's likely that these functions are built-in JavaScript methods or utilities, as there's no explicit reference to external libraries.

**Special JS Features/Syntax:**

There is no mention of special JavaScript features or syntax in this benchmark. The focus is on comparing different approaches to a specific problem.

**Other Alternatives:**

If you were to rewrite these benchmarks with alternative approaches, some options could include:

* Using a `Set` data structure for the alphabet string instead of an array.
* Employing a more advanced regular expression pattern or using a library like `regex-escape`.
* Utilizing a custom-made function that takes into account the specific requirements and optimizations of each approach.

In terms of browser-specific alternatives, you could consider testing:

* Using the `String.prototype.match()` method instead of `charCodeAt()`
* Employing the `Intl` API for Unicode code point operations
* Using the `text-regex` library for regular expression optimizations

Keep in mind that the best alternative will depend on your specific use case and requirements.

Latest run results:

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

User agent: Mozilla/5.0 (Android 11; Mobile; rv:103.0) Gecko/103.0 Firefox/103.0

Browser/OS: Firefox Mobile 103 on Android

View result in a separate tab

Test name	Executions per second
regex	15863807.0 Ops/sec
alphaIncludes	21155022.0 Ops/sec
charCodeBetween	667592320.0 Ops/sec

Related benchmarks:

Check if character is not a lowercase letter (version: 0)

regex test vs alphabet string includes vs charCodeAt

Comparing performance of: regex vs alphaIncludes vs charCodeBetween

Created: 2 years ago by: Guest

Jump to the latest result

regex

alphaIncludes

charCodeBetween

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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