Benchmark: Javascript: Case insensitive string comparison indexOf vs includes 2

Script Preparation code:

var words = Array.from({ length: 1000 }, (_, i) => `word${i + 1}`);
var searchString = "WORD512";
var searchStringRegex = new RegExp(searchString, 'i');

Tests:

toLowerCase_includes
const filteredCase1 = words.filter(word => word.toLowerCase().includes(searchString.toLowerCase()));
Regex_indexOf
const filteredCase2 = words.filter(word => searchStringRegex.test(word));

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Regex_indexOf

48K/s

toLowerCase_includes

35K/s

Fastest: Regex_indexOf (1.4x faster)

View exact numbers

✓ Regex_indexOf: 47,585 ops/sec
• toLowerCase_includes: 35,130 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
toLowerCase_includes
Regex_indexOf

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 22 days ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 27_0_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/150.0.7871.113 Mobile/15E148 Safari/604.1

Browser/OS: Chrome Mobile iOS 150 on iOS 27.0.0

View result in a separate tab

Regex_indexOf

264K/s

toLowerCase_includes

34K/s

View exact numbers

Test name	Executions per second
✓ Regex_indexOf	263,919 Ops/sec
toLowerCase_includes	34,013 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 benchmarking scenario:

**Benchmark Definition**

The benchmark is designed to compare two approaches for case-insensitive string comparison in JavaScript: `indexOf` with regular expressions and `includes` method.

**Script Preparation Code**

The script preparation code creates an array of 1000 words, each word being a sequence of "word" followed by a number from 1 to 1000. It also sets up two variables:

* `searchString`: a string "WORD512"
* `searchStringRegex`: a regular expression created from `searchString` with the 'i' flag (case-insensitive)

The purpose of this script preparation code is to provide a consistent and controlled environment for the benchmarking test cases.

**Html Preparation Code**

There is no HTML preparation code provided, which suggests that this benchmark is focused on JavaScript performance alone.

**Individual Test Cases**

There are two individual test cases:

1. **toLowerCase_includes**: This test case uses the `filter()` method with a callback function that checks if a word includes the lowercase version of the search string (`searchString.toLowerCase()`) using the `includes()` method.
2. **Regex_indexOf**: This test case uses the `filter()` method with a callback function that checks if a word matches the regular expression created from the search string (`searchStringRegex`) for case-insensitive matching.

**Library and Purpose**

In both test cases, the `Array.prototype.filter()` method is used to filter the array of words. The `includes()` method is also used in one of the test cases. These are built-in JavaScript methods that do not require any external libraries.

There are no special JavaScript features or syntax mentioned in this benchmark.

**Options Compared**

The two options being compared are:

1. **toLowerCase_includes**: uses the `filter()` method with a callback function and the `includes()` method.
2. **Regex_indexOf**: uses the `filter()` method with a callback function and a regular expression for case-insensitive matching.

**Pros and Cons of Each Approach**

Here's a brief overview of each approach:

1. **toLowerCase_includes**:
	* Pros: simple, easy to read, and understand.
	* Cons: may be slower than using a regular expression due to the overhead of calling `toLowerCase()` on each string.
2. **Regex_indexOf**:
	* Pros: can provide more flexible matching options, such as matching an empty string or using flags like 'g' for global matching.
	* Cons: may be less readable and maintainable than using a simple callback function, especially for complex patterns.

**Other Considerations**

The benchmarking scenario assumes that the `filter()` method is optimized for performance, which might not always be the case in production code. Additionally, the use of `includes()` method might depend on the specific requirements of the application, such as finding multiple occurrences of a substring.

In terms of alternatives, there are other ways to perform string matching in JavaScript, such as using a library like `indexOf` or `match`, but these options are not explicitly mentioned in this benchmark.

Javascript: Case insensitive string comparison indexOf vs includes 2 (version: 0)

Comparing performance of: `toLowerCase_includes vs Regex_indexOf`

Created: one year ago by: Guest

Go to the latest result

toLowerCase_includes

Regex_indexOf

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 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):

Javascript: Case insensitive string comparison indexOf vs includes 2 (version: 0)

Comparing performance of: toLowerCase_includes vs Regex_indexOf

Created: one year ago by: Guest

Go to the latest result

toLowerCase_includes

Regex_indexOf

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 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: `toLowerCase_includes vs Regex_indexOf`