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

Script Preparation code:

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

Tests:

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 108 on Windows

View result in a separate tab

Test name	Executions per second
regexp .test()	10592424.0 Ops/sec
string .includes()	16440964.0 Ops/sec
indexOf === 0	16447940.0 Ops/sec
string .startsWith()	12037136.0 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 benchmark definition and test cases.

**Benchmark Definition:**
The benchmark is testing four different string manipulation methods:

1. `startsWith()`
2. `includes()`
3. `indexOf()`
4. Regular Expression `.test()` (using a RegExp object)

These methods are used to check if a given string starts with, contains, or has a specific index of a certain substring.

**Script Preparation Code:**
The script is prepared by defining a variable `html` containing the URL "https://www.google.com".

**Options Compared:**

* `startsWith()`: checks if the string starts with a specified value.
	+ Pros: Simple and efficient for simple cases.
	+ Cons: May be slower for longer strings or more complex searches, as it involves substring comparison.
* `includes()`: checks if the string contains a specified value.
	+ Pros: Generally faster than `startsWith()` and `indexOf()` due to its optimized implementation.
	+ Cons: May not be suitable for exact matching (e.g., checking if a string is equal to another), as it returns true for substrings within the original string.
* `indexOf()`: checks if the string contains a specified value at a specific index.
	+ Pros: Fast and efficient for exact matches, but may be slower than `includes()` due to its more complex implementation.
	+ Cons: May return -1 (not found) instead of false, which can lead to unexpected behavior in some cases.
* Regular Expression `.test()`: checks if a string passes a test based on a pattern.
	+ Pros: Flexible and powerful for complex patterns and regular expressions, but may be slower than the other methods due to its overhead.
	+ Cons: May be more difficult to read and maintain, especially for complex patterns.

**Library Used:** None

The benchmark does not use any external libraries beyond JavaScript's built-in string manipulation functions. However, it relies on the browser's implementation of these functions, which may vary between browsers and versions.

**Special JS Feature/Syntax:** None mentioned in this explanation.

**Other Alternatives:**

* For a more comprehensive comparison, you might consider adding tests for other string manipulation methods, such as `localeCompare()` or using regular expressions with `.match()`.
* You could also explore using optimized libraries like `lodash.string` or `string.prototype.equals()` to compare the performance of different string manipulation methods.
* To make the benchmark more representative, you might add additional test cases that cover edge cases, such as empty strings, null, or undefined values.

Keep in mind that the specific alternatives and test cases will depend on your goals and requirements for this benchmark.

Related benchmarks:

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

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

Created: 2 years ago by: Registered User

Jump to the latest result

regexp .test()

string .includes()

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