Benchmark: v2: .startsWith() vs .test() vs .match() vs .indexOf()

Script Preparation code:

var html = "https://www.google.com";
var rx = /^https:\/\//;
var s = 'https://';

Tests:

regexp .test()
rx.test(html)
string .match()
!!html.match(rx)
indexOf === 0
html.indexOf(s) === 0
string .startsWith()
html.startsWith(s)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regexp .test()
string .match()
indexOf === 0
string .startsWith()

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36

Browser/OS: Chrome 96 on Windows

View result in a separate tab

Test name	Executions per second
regexp .test()	6296751.5 Ops/sec
string .match()	5410488.0 Ops/sec
indexOf === 0	7364197.5 Ops/sec
string .startsWith()	6544135.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and understand what's being tested.

**Overview**

The benchmark is designed to compare the performance of four different string comparison methods:

1. `regexp.test()`
2. `string.match()`
3. `indexOf === 0` (note that this is not a standard JavaScript method, but rather a custom test case)
4. `string.startsWith()`

**Regexp .test()**

The first test case uses the regular expression `rx = /^https:\\/\\//;` to match strings starting with "https://". The `test()` method is then called on this regex object and passed the string `html`. This method returns a boolean indicating whether the string matches the pattern.

Pros:

* Regular expressions can be very powerful for complex matching tasks.
* This method is often used in situations where a simple string comparison isn't enough.

Cons:

* Regular expressions can be computationally expensive, especially for large strings or complex patterns.
* The performance may suffer due to the overhead of parsing and compiling the regex pattern.

**String .match()**

The second test case uses the `match()` method on the string `html` with the same regex pattern as before. This method returns an array containing matches if any, otherwise null.

Pros:

* `match()` is a relatively simple method compared to `test()`, which can make it faster in performance.
* It can be used for both matching and extracting substrings from a larger string.

Cons:

* The performance may vary depending on the length of the input string or the complexity of the pattern.
* The return type can be an array, which might require additional processing steps.

**indexOf === 0**

The third test case is a custom test case that simply checks if the index of `html` equals 0 when searching for the substring `s`. This method is essentially checking if the string starts with "https://".

Pros:

* Simple and straightforward to understand.
* Fast because it only involves simple array indexing operations.

Cons:

* Not suitable for all types of strings (e.g., empty strings, null values).
* May not be as efficient as other methods for large strings or complex patterns.

**String .startsWith()**

The fourth test case uses the `startsWith()` method on the string `html` with the same substring `s`. This method returns a boolean indicating whether the string starts with the specified value.

Pros:

* Simple and straightforward to understand.
* Fast because it only involves simple array indexing operations.
* Suitable for all types of strings (e.g., empty strings, null values).

Cons:

* May not be as efficient as other methods for large strings or complex patterns.

**Library**

In this benchmark, no specific library is used beyond the built-in `RegExp` and `String` objects. The `RegExp` object is used to create a regex pattern, while the `String` object provides methods like `match()`, `startsWith()`, and `indexOf()` for string comparison.

**Special JavaScript Features**

None of the test cases mentioned in the provided JSON use any special JavaScript features or syntax beyond standard JavaScript language elements.

Related benchmarks:

v2: .startsWith() vs .test() vs .match() vs .indexOf() (version: 0)

Comparing performance of: regexp .test() vs string .match() vs indexOf === 0 vs string .startsWith()

Created: 3 years ago by: Guest

Jump to the latest result

regexp .test()

string .match()

indexOf === 0

string .startsWith()

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