Benchmark: startswith vs includes vs not match includes 2

Tests:

includes
const str = "https://firebase.com/this/is/a/long/thing" str.includes("https://firebase")
startsWith
const str = "https://firebase.com/this/is/a/long/thing" str.startsWith("https://firebase")
includes not match
const str = "https://firebase.com/this/is/a/long/thing" str.includes("https://firebasc")

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
startsWith
includes not match

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 90 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
includes	35430732.0 Ops/sec
startsWith	31058156.0 Ops/sec
includes not match	25742632.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmark created on MeasureThat.net. The benchmark compares three string matching functions in JavaScript: `startsWith`, `includes`, and `not matches` (a custom implementation). Each test case measures the performance of one of these functions.

**Options Compared**

The options being compared are:

1. `startsWith`
2. `includes`

Both functions are used to match a substring within a given string. The main difference between them is the direction of matching:

* `startsWith` checks if the string starts with the specified substring.
* `includes` checks if the string contains the specified substring.

**Pros and Cons**

Here's a brief overview of each function's pros and cons:

### `startsWith`

Pros:

* Faster execution time, as it can stop searching once the match is found.
* More efficient when searching for prefixes.

Cons:

* May not be suitable for full-text search or matching substrings in the middle of the string.

### `includes`

Pros:

* Suitable for full-text search or matching substrings anywhere within the string.
* Can handle cases where the substring appears multiple times.

Cons:

* Slower execution time, as it needs to search through the entire string.
* May be less efficient when searching for prefixes.

**Other Considerations**

1. **Regular Expressions**: `startsWith` and `includes` can use optimized regular expression matching under the hood, which can impact performance. MeasureThat.net may be using the V8 JavaScript engine, which supports optimized regex matching.
2. **String Length**: The length of the input string can affect performance. Longer strings will generally require more time to search.

**Library and Special Features**

The benchmark uses no external libraries or special features beyond standard JavaScript. No ES6+ features are mentioned in the provided code.

**Other Alternatives**

If you were to run this benchmark on your own, some alternative approaches could be explored:

1. Using a regular expression with `RegExp.test()` instead of `startsWith` and `includes`.
2. Implementing custom string matching using a loop or recursion.
3. Comparing performance with different JavaScript engines (e.g., Node.js, V8, SpiderMonkey).
4. Measuring performance with varying input sizes or complexities.

Keep in mind that these alternatives would likely require significant changes to the benchmark code and may not be directly comparable to the original implementation.

Related benchmarks:

startswith vs includes vs not match includes 2 (version: 0)

Comparing performance of: includes vs startsWith vs includes not match

Created: 3 years ago by: Guest

Jump to the latest result

includes

startsWith

includes not match

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