Benchmark: RegEx.test vs Array.includes (Lowercase)

Script Preparation code:

var appState = "active";
var regex = /inactive|background/i;
var arr = ['inactive', 'background'];

Tests:

RegEx.test
regex.test(appState);
Array.includes
arr.includes(appState.toLowerCase());

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
Array.includes

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated yesterday):

LLMs can make mistakes. Check important info.

I'd be happy to explain what's being tested in this benchmark.

**What is being tested?**

The provided JSON represents two test cases that compare the performance of regular expression testing (`regex.test`) versus using the `Array.includes` method with a lowercase string comparison. The tests are designed to measure the execution speed of each approach on a specific input string (`appState = "active"`).

**Options compared:**

1. **Regex.test**: This method uses a regular expression to test if the input string matches a pattern.
2. **Array.includes**: This method checks if an element exists in an array.

**Pros and Cons:**

* `regex.test`:
	+ Pros: Can be used to test for more complex patterns, allows for flexible matching, and can be optimized with flags (e.g., `i` for case-insensitive match).
	+ Cons: May have higher overhead due to the complexity of regular expression parsing and matching.
* `Array.includes`:
	+ Pros: Generally faster than regex testing, as it uses a simple array lookup. Also, it's often more readable and easier to maintain.
	+ Cons: Limited to checking if an exact match exists in the array; not suitable for complex pattern matching.

**Library usage:**

In this benchmark, no external libraries are used beyond JavaScript core functionality.

**Special JS feature or syntax:**

None mentioned. The test cases only use standard JavaScript features and syntax.

**Other alternatives:**

For a more robust comparison, you might consider testing:

* `String.prototype.includes`: Similar to `Array.includes`, but optimized for strings.
* Other regular expression methods (e.g., `regex.test()` with flags): To explore the impact of flags on performance.

Keep in mind that this benchmark is focused on comparing two specific approaches rather than exploring the broader landscape of JavaScript performance optimization techniques.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.66 Safari/537.36 Edg/103.0.1264.44

Browser/OS: Chrome 103 on Linux

View result in a separate tab

Test name	Executions per second
RegEx.test	8727078.0 Ops/sec
Array.includes	8768052.0 Ops/sec

Related benchmarks:

RegEx.test vs Array.includes (Lowercase) (version: 0)

Comparing performance of: RegEx.test vs Array.includes

Created: 2 years ago by: Guest

Jump to the latest result

RegEx.test

Array.includes

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated yesterday):