Benchmark: includes + toLowerCase vs RegExp + i

Script Preparation code:

var str = "This is a simple test!";
var needle = "sImPle";

Tests:

lowercase + includes
str.toLowerCase().includes(needle.toLowerCase())
RegExp + i
new RegExp(needle, 'i').test(str);

Historical Performance Data aggregated from 48 community runs

Desktop Results:

Chrome 43 runs

lowercase + includes

13.5M/s

RegExp + i

5.4M/s

Fastest: lowercase + includes (2.5x faster)

View exact numbers

✓ lowercase + includes: 13,450,656 ops/sec
• RegExp + i: 5,354,394 ops/sec

Firefox 5 runs

lowercase + includes

1962.3M/s

RegExp + i

20.2M/s

Fastest: lowercase + includes (96.9x faster)

View exact numbers

✓ lowercase + includes: 1,962,320,256 ops/sec
• RegExp + i: 20,246,960 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
lowercase + includes
RegExp + i

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36

Browser/OS: Chrome 144 on Mac OS X 10.15.7

View result in a separate tab

lowercase + includes

45.1M/s

RegExp + i

15.0M/s

View exact numbers

Test name	Executions per second
✓ lowercase + includes	45,113,416 Ops/sec
RegExp + i	15,021,206 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's being tested.

**Benchmark Definition**

The benchmark is defined by two test cases:

1. `lowercase + includes`: This test case measures the performance of using the `toLowerCase()` method followed by the `includes()` method to search for a substring within a string.
2. `RegExp + i`: This test case measures the performance of using a regular expression with the `i` flag (which makes the regex match in a case-insensitive manner) to search for a substring within a string.

**Options Compared**

In this benchmark, two approaches are being compared:

* Using the `toLowerCase()` method followed by `includes()`: This approach involves converting both the input string and the needle to lowercase before searching for the substring.
* Using a regular expression with the `i` flag: This approach involves creating a regex pattern that matches the substring in a case-insensitive manner.

**Pros and Cons of Each Approach**

1. **Using `toLowerCase()` method followed by `includes()`:**
	* Pros:
		+ Easy to implement and understand.
		+ Works well for simple cases where the input string is not too large.
	* Cons:
		+ Can be slower than using a regex pattern, especially for larger input strings.
		+ Requires two separate operations (converting to lowercase and searching), which can lead to overhead.
2. **Using a regular expression with the `i` flag:**
	* Pros:
		+ More efficient and flexible than the first approach, as it allows matching in a case-insensitive manner.
		+ Can handle more complex cases where the input string is large or contains special characters.
	* Cons:
		+ Requires knowledge of regex patterns, which can be intimidating for beginners.
		+ May not work well for all use cases (e.g., some libraries may not support regex flags).

**Library and Purpose**

There is no explicit library mentioned in the benchmark definition. However, it's likely that the `toLowerCase()` method and the regular expression pattern are part of the JavaScript standard library.

**Special JS Feature or Syntax**

Neither of the test cases uses a special JavaScript feature or syntax that requires explanation. Both approaches rely on basic string manipulation methods.

**Other Alternatives**

If you were to modify this benchmark, you might consider adding additional test cases, such as:

* Using the `i` flag with a regex pattern (e.g., `new RegExp(needle, 'gi')`) for case-insensitive matching.
* Adding performance metrics for different input sizes or complexity levels.
* Comparing the performance of these approaches using other browsers or platforms.

Keep in mind that the goal of this benchmark is to compare the performance of two approaches, so any additional test cases should aim to provide more comprehensive insights into each approach's strengths and weaknesses.

includes + toLowerCase vs RegExp + i (version: 0)

Comparing performance of: `lowercase + includes vs RegExp + i`

Created: 3 years ago by: Guest

Go to the latest result

lowercase + includes

RegExp + i

Historical Performance Data aggregated from 48 community runs

Desktop Results:

Chrome 43 runs

Firefox 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

includes + toLowerCase vs RegExp + i (version: 0)

Comparing performance of: lowercase + includes vs RegExp + i

Created: 3 years ago by: Guest

Go to the latest result

lowercase + includes

RegExp + i

Historical Performance Data aggregated from 48 community runs

Desktop Results:

Chrome 43 runs

Firefox 5 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: `lowercase + includes vs RegExp + i`