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

Historical Performance Data aggregated from 100 community runs

Desktop Results:

Chrome 81 runs

indexOf === 0

27.7M/s

string .startsWith()

20.8M/s

regexp .test()

18.0M/s

string .match()

15.1M/s

Fastest: indexOf === 0 (1.8x faster)

View exact numbers

✓ indexOf === 0: 27,733,116 ops/sec
• string .startsWith(): 20,758,642 ops/sec
• regexp .test(): 18,033,082 ops/sec
• string .match(): 15,057,943 ops/sec

Firefox 12 runs

string .startsWith()

1241.5M/s

indexOf === 0

1192.8M/s

regexp .test()

37.9M/s

string .match()

19.0M/s

Fastest: string .startsWith() (65.3x faster)

View exact numbers

✓ string .startsWith(): 1,241,519,616 ops/sec
• indexOf === 0: 1,192,801,024 ops/sec
• regexp .test(): 37,859,568 ops/sec
• string .match(): 19,008,640 ops/sec

Safari 7 runs

indexOf === 0

30.3M/s

regexp .test()

26.3M/s

string .startsWith()

21.8M/s

string .match()

17.8M/s

Fastest: indexOf === 0 (1.7x faster)

View exact numbers

✓ indexOf === 0: 30,282,676 ops/sec
• regexp .test(): 26,339,190 ops/sec
• string .startsWith(): 21,756,602 ops/sec
• string .match(): 17,803,916 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
regexp .test()
string .match()
indexOf === 0
string .startsWith()

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 months ago)

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

Browser/OS: Chrome 143 on Mac OS X 10.15.7

View result in a separate tab

indexOf === 0

250.4M/s

string .startsWith()

93.6M/s

regexp .test()

81.9M/s

string .match()

48.6M/s

View exact numbers

Test name	Executions per second
✓ indexOf === 0	250,359,744 Ops/sec
string .startsWith()	93,625,504 Ops/sec
regexp .test()	81,914,960 Ops/sec
string .match()	48,623,404 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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

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

Created: 5 years ago by: Guest

Go to the latest result

regexp .test()

string .match()

indexOf === 0

string .startsWith()

Historical Performance Data aggregated from 100 community runs

Desktop Results:

Chrome 81 runs

Firefox 12 runs

Safari 7 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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

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

Created: 5 years ago by: Guest

Go to the latest result

regexp .test()

string .match()

indexOf === 0

string .startsWith()

Historical Performance Data aggregated from 100 community runs

Desktop Results:

Chrome 81 runs

Firefox 12 runs

Safari 7 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: `regexp .test() vs string .match() vs indexOf === 0 vs string .startsWith()`