Benchmark: RegExp#test vs String#indexOf vs String#match vs pre-allocated RegExp

HTML Preparation code:

<div>This is demo</div>

Script Preparation code:

console.log("js preparation");
var re = /o/;

Tests:

RegExp#test
/o/.test('Hello World!');
String#indexOf
'Hello World!'.indexOf('o') > -1;
String#match
!!'Hello World!'.match(/o/);
Preallocated RegExp#test
re.test('Hello World!');
Preallocated String#match
!!'Hellow World!'.match(re);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegExp#test
String#indexOf
String#match
Preallocated RegExp#test
Preallocated String#match

Fastest: N/A

Slowest: N/A

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/106.0.0.0 Safari/537.36

Browser/OS: Chrome 106 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
RegExp#test	80133112.0 Ops/sec
String#indexOf	1029304192.0 Ops/sec
String#match	43567412.0 Ops/sec
Preallocated RegExp#test	20731668.0 Ops/sec
Preallocated String#match	15486220.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance is an essential task for any developer, and MeasuringThat.net provides a fantastic platform to do just that.

**Benchmark Overview**

The provided benchmark compares the performance of four approaches:

1. **RegExp#test**: Using the `test()` method on a regular expression object.
2. **String#indexOf**: Using the `indexOf()` method on a string.
3. **String#match**: Using the `match()` method on a string, which returns an array if found, or null otherwise.
4. **Pre-allocated RegExp**: Creating a pre-allocated regular expression object and using its `test()` method.

**Options Compared**

Each approach is compared in terms of execution speed, with the goal of finding the fastest way to perform the search operation.

**Pros and Cons**

* **RegExp#test**:
	+ Pros: Can be faster than other methods for large strings or when searching for a specific pattern.
	+ Cons: May be slower for small strings or simple searches due to the overhead of compiling the regular expression.
* **String#indexOf**:
	+ Pros: Generally faster and more efficient than RegExp#test, especially for short strings.
	+ Cons: Can be slower for large strings or complex searches, as it performs a linear search.
* **String#match**:
	+ Pros: Can return multiple matches in an array, making it useful for certain use cases.
	+ Cons: May be slower than other methods due to the overhead of creating and searching for arrays.
* **Pre-allocated RegExp**:
	+ Pros: Can be faster than RegExp#test when the same regular expression is used repeatedly, as the compilation overhead is only done once.
	+ Cons: Requires more memory to store the pre-allocated regular expression object.

**Library Usage**

None of the approaches in this benchmark use external libraries.

**Special JS Features/Syntax**

There are no special JavaScript features or syntax mentioned in the provided code. However, it's worth noting that some older browsers may have different behavior or performance characteristics for certain methods due to their implementation details.

**Other Alternatives**

If you're interested in exploring alternative approaches, consider the following:

* Using a library like Lodash or Ramda, which provide optimized implementations of common functions like `indexOf` and `match`.
* Implementing your own search algorithms using techniques like Boyer-Moore or Knuth-Morris-Pratt for more efficient string matching.
* Using JavaScript engines with built-in performance optimizations, such as V8 (used by Chrome) or SpiderMonkey (used by Firefox).

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

Related benchmarks:

RegExp#test vs String#indexOf vs String#match vs pre-allocated RegExp (version: 0)

From https://benchmarkjs.com/

Comparing performance of: RegExp#test vs String#indexOf vs String#match vs Preallocated RegExp#test vs Preallocated String#match

Created: 2 years ago by: Guest

Jump to the latest result

RegExp#test

String#indexOf

String#match

Preallocated RegExp#test

Preallocated String#match

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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