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

Script Preparation code:

var html = "https://www.google.com";

Tests:

regexp .test()
/^https?:\/\//.test(html)
string .match()
!!html.match(/^https:\/\//)
indexOf === 0
html.indexOf('http://') === 0
string .startsWith()
html.startsWith('https://')

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: 24 days ago)

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

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
regexp .test()	30185762.0 Ops/sec
string .match()	17170782.0 Ops/sec
indexOf === 0	106481856.0 Ops/sec
string .startsWith()	47714544.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition**

The provided JSON represents a benchmarking test case that compares the performance of four different string manipulation methods: `startsWith()`, `test()`, `match()`, and `indexOf()`. The test case is designed to measure which method is the fastest for checking if a given URL starts with a specific prefix.

**Options Compared**

The options compared in this benchmark are:

1. `startsWith()`: A built-in JavaScript method that returns true if the string starts with the specified value.
2. `test()`: A RegExp testing method that returns true if the string matches the pattern.
3. `match()`: A RegExp matching method that returns an array of strings if the string matches the pattern, or null if it doesn't match.
4. `indexOf()`: A built-in JavaScript method that returns the index of the first occurrence of the specified value in the string.

**Pros and Cons**

Here's a brief summary of the pros and cons of each option:

1. `startsWith()`:
	* Pros: Fast, simple, and intuitive.
	* Cons: May not be as flexible as other options (e.g., it doesn't support regular expressions).
2. `test()`:
	* Pros: Flexible and can be used with regular expressions.
	* Cons: May be slower than other methods due to the overhead of RegExp creation and matching.
3. `match()`:
	* Pros: Can be used with regular expressions, which allows for more flexibility.
	* Cons: Returns an array or null, which may not always be what you expect, and can be slower than `startsWith()` in some cases.
4. `indexOf()`:
	* Pros: Fast and widely supported.
	* Cons: May return -1 if the value is not found, which can lead to errors in some cases.

**Library Usage**

The test case uses the `RegExp` library for its `test()` method. The `RegExp` library provides support for regular expressions, which allows for more flexible pattern matching.

**Special JS Features or Syntax**

None of the individual test cases use any special JavaScript features or syntax that would affect their performance in a significant way.

**Other Considerations**

When choosing between these methods, consider the following factors:

* Performance: If speed is crucial, `startsWith()` and `indexOf()` may be better choices.
* Flexibility: If you need to match complex patterns, `test()` and `match()` might be more suitable.
* Readability: `startsWith()` is often the most readable option, as it clearly conveys its purpose.

**Alternatives**

Other alternatives for string manipulation methods include:

1. `includes()`: A newer method that returns true if a substring is included in the original string (introduced in ECMAScript 2020).
2. `endsWith()`: A new method introduced in ECMAScript 2019, which returns true if the string ends with the specified value.
3. Custom solutions using `String.prototype.localeCompare()` or `String.prototype.indexOf()`.

Keep in mind that the performance of these alternatives may vary depending on the specific use case and requirements.

Related benchmarks:

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

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

Created: 4 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 6 months ago):