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

Script Preparation code:

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

Tests:

regexp .test()
/^https?:\/\//.test(html)
string .match()
!!html.match(/^https:\/\//)
indexOf === 0
html.indexOf('https://') === 0
string .startsWith()
html.startsWith('https://')
regexp .test() failure
/^https?:\/\//.test(html)
string .match() failure
!!html.match(/^https:\/\//)
indexOf === 0 failure
html.indexOf('https://') === 0
string .startsWith() failure
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()
regexp .test() failure
string .match() failure
indexOf === 0 failure
string .startsWith() failure

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 provided benchmark definition and test cases.

**Benchmark Overview**

The benchmark compares the performance of four different string manipulation methods:

1. `startsWith()`
2. `.test()` (regular expression)
3. `.match()` (regular expression)
4. `.indexOf()` with a failure condition (`=== 0`)

These methods are used to check if a given string starts with or matches a specific pattern.

**Options Compared**

* `startsWith()`: checks if the string starts with a specified value
* `.test()` (regular expression): checks if the string passes a regular expression test
* `.match()` (regular expression): searches for a match of a regular expression in the string
* `.indexOf()` with a failure condition (`=== 0`): checks if the first character of the string is equal to a specified value

**Pros and Cons**

1. **startsWith()**:
	* Pros: simple, efficient, and widely supported
	* Cons: can be slow for large strings or complex patterns
2. `.test()` (regular expression):
	* Pros: flexible, powerful, and can handle complex patterns
	* Cons: can be slower than `startsWith()`, and regular expressions can be complex to write and optimize
3. `.match()` (regular expression):
	* Pros: similar to `.test()`, but can return a match object if found
	* Cons: can be slower than `startsWith()`, and regular expressions can be complex to write and optimize
4. `.indexOf()` with a failure condition (`=== 0`):
	* Pros: simple, efficient, and widely supported
	* Cons: can be slow for large strings or performance-critical applications

**Library Usage**

No specific libraries are mentioned in the benchmark definition.

**Special JS Features or Syntax**

None of the tests use special JavaScript features or syntax that would require additional explanation.

**Alternative Approaches**

Other approaches to string manipulation could include:

* Using `startsWith()` and checking for a specific substring
* Using regular expressions to search for multiple patterns in the string
* Using `indexOf()` and checking for a specific character range
* Using other libraries like Lodash or Ramda for string manipulation

Keep in mind that these alternative approaches may have different performance characteristics, pros, and cons compared to the methods used in this benchmark.

Latest run results:

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

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

Browser/OS: Chrome 123 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
regexp .test()	17450186.0 Ops/sec
string .match()	14155647.0 Ops/sec
indexOf === 0	26731626.0 Ops/sec
string .startsWith()	19714600.0 Ops/sec
regexp .test() failure	17556494.0 Ops/sec
string .match() failure	14471784.0 Ops/sec
indexOf === 0 failure	26399540.0 Ops/sec
string .startsWith() failure	19662736.0 Ops/sec

Related benchmarks:

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

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

Created: 2 years ago by: Guest

Jump to the latest result

regexp .test()

string .match()

indexOf === 0

string .startsWith()

regexp .test() failure

string .match() failure

indexOf === 0 failure

string .startsWith() failure

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