Benchmark: indexOf vs regex vs RegExp regexp fork

Script Preparation code:

var str = "This is a simple test!";
var needle = "simple";
var ri = new RegExp('simple', 'i');

Tests:

lowercase, trim, indexof
var a = str.toLowerCase().trim(); var b = needle.toLowerCase().trim(); var c = a.indexOf(b) > -1;
trim, lowercase, indexof
var a = str.trim().toLowerCase(); var b = needle.trim().toLowerCase(); var c = a.indexOf(b) > -1;
regex
var c = ri.test(str);
lowercase, replace, indexof
var a = str.toLowerCase().replace(" ", ""); var b = needle.toLowerCase().replace(" ", ""); var c = a.indexOf(b) > -1;
RegExp
var c = (new RegExp(needle, 'i')).test(str);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lowercase, trim, indexof
trim, lowercase, indexof
regex
lowercase, replace, indexof
RegExp

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark definition and test cases to understand what is being tested.

**Benchmark Definition**

The benchmark defines four different approaches to search for a substring in a string:

1. `indexOf` method
2. Regular Expression (Regex) with the `/i` flag for case-insensitivity
3. RegExp object with the `test()` method
4. A modified version of the `replace()` method, which is not typically used for searching substrings.

**Options Compared**

The benchmark compares the performance of these four approaches in terms of:

* Speed: The number of executions per second (ExecutionsPerSecond)
* Consistency: The consistency of results across different browser versions and platforms

**Pros and Cons**

1. `indexOf` method:
	* Pros: Fast, widely supported, and efficient.
	* Cons: May not be suitable for case-insensitive searches or when the string is modified during the search process.
2. Regular Expression (Regex) with the `/i` flag:
	* Pros: Powerful for regular expression matching, can handle complex patterns, and provides a way to match case insensitively.
	* Cons: Can be slower than other methods due to the overhead of compiling and executing regex patterns.
3. RegExp object with the `test()` method:
	* Pros: More efficient than using a regex pattern with the `/i` flag, as it avoids the compilation step.
	* Cons: Less powerful than the full regex engine, may not support all features, and can be slower for complex patterns.
4. Modified version of the `replace()` method:
	* Pros: Not typically used for searching substrings, so its performance might not be relevant in this context.
	* Cons: Not suitable for this benchmarking purpose.

**Library and Purpose**

In one of the test cases, a library is used:

* In the "Regex" test case, the `RegExp` constructor is used to create a regex pattern. The `RegExp` object provides a way to define regular expression patterns and execute them on strings.
* In the "RegExp" test case, a new `RegExp` object is created with a specific pattern and flags.

**Special JS Feature or Syntax**

None of the benchmark tests use special JavaScript features or syntax beyond what's standard in JavaScript. The use of regex patterns is simply for string matching.

**Other Alternatives**

If the focus were to compare other approaches, some alternatives could be:

* Using `String.prototype.includes()` method instead of `indexOf()`
* Implementing a custom search algorithm using bitwise operations
* Comparing performance with other search algorithms like binary search or interpolation search
* Evaluating the impact of different string normalization techniques (e.g., trimming, lowercasing) on search performance

Keep in mind that these alternatives would require additional test cases and considerations to ensure a fair comparison.

Overall, this benchmark provides insight into the relative performance of four common approaches for searching substrings in JavaScript strings.

Latest run results:

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

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

Browser/OS: Chrome 105 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lowercase, trim, indexof	9328073.0 Ops/sec
trim, lowercase, indexof	10035937.0 Ops/sec
regex	10729252.0 Ops/sec
lowercase, replace, indexof	4305458.0 Ops/sec
RegExp	4651370.0 Ops/sec

Related benchmarks:

indexOf vs regex vs RegExp regexp fork (version: 0)

Comparing performance of: lowercase, trim, indexof vs trim, lowercase, indexof vs regex vs lowercase, replace, indexof vs RegExp

Created: 2 years ago by: Guest

Jump to the latest result

lowercase, trim, indexof

trim, lowercase, indexof

regex

lowercase, replace, indexof

RegExp

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):