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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:148.0) Gecko/20100101 Firefox/148.0

Browser/OS: Firefox 148 on Mac OS X 10.15

View result in a separate tab

string .includes()

618.0M/s

string .startsWith()

587.2M/s

indexOf === 0

568.3M/s

regexp .test()

24.3M/s

View exact numbers

Test name	Executions per second
✓ string .includes()	618,025,280 Ops/sec
string .startsWith()	587,229,248 Ops/sec
indexOf === 0	568,251,776 Ops/sec
regexp .test()	24,342,452 Ops/sec

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

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

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

Created: 3 years ago by: Registered User

Go to the latest result

regexp .test()

string .includes()

indexOf === 0

string .startsWith()

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 .includes() vs .indexOf() (version: 0) Benchmark.js

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

Created: 3 years ago by: Registered User

Go to the latest result

regexp .test()

string .includes()

indexOf === 0

string .startsWith()

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 .includes() vs indexOf === 0 vs string .startsWith()`