Benchmark: startswith vs includes3

Tests:

includes
const str = "https://firebasestorage.googleapis.com/v0/b/a-sketch-a-day-207420.appspot.com/o/" str.includes("firebasestorage")
startsWith
const str = "https://firebasestorage.googleapis.com/v0/b/a-sketch-a-day-207420.appspot.com/o/" str.startsWith("https://fire")
indexOf starts
const str = "https://firebasestorage.googleapis.com/v0/b/a-sketch-a-day-207420.appspot.com/o/" str.indexOf("https://fire") === 0
indexOf somewhere
const str = "https://firebasestorage.googleapis.com/v0/b/a-sketch-a-day-207420.appspot.com/o/" str.indexOf("firebasestorage") > -1

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
startsWith
indexOf starts
indexOf somewhere

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark test cases and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition Json**

The provided JSON defines a benchmark with no script preparation code or HTML preparation code. This means that the benchmarks are designed to be run directly in the browser without any additional setup.

**Test Cases**

There are four individual test cases:

1. `includes`
2. `startsWith`
3. `indexOf starts`
4. `indexOf somewhere`

Let's analyze each test case:

### 1. `includes`

```json
"Benchmark Definition": "const str = \"https://firebasestorage.googleapis.com/v0/b/a-sketch-a-day-207420.appspot.com/o/\"\r\nstr.includes(\"firebasestorage\")"
```

This benchmark tests the performance of the `includes` method, which returns `true` if a string contains a specified value.

**Pros and Cons:**

* Pros:
	+ Simple and easy to understand.
	+ Relevant for use cases where a substring is searched in a larger string.
* Cons:
	+ May be slower than other methods due to the need to iterate over the string.
	+ Less efficient than `startsWith` or `indexOf` when searching for a specific substring.

### 2. `startsWith`

```json
"Benchmark Definition": "const str = \"https://firebasestorage.googleapis.com/v0/b/a-sketch-a-day-207420.appspot.com/o/\"\r\nstr.startsWith(\"https://fire\")"
```

This benchmark tests the performance of the `startsWith` method, which returns `true` if a string starts with a specified value.

**Pros and Cons:**

* Pros:
	+ Often faster than `includes` since it only requires checking the first few characters.
	+ Efficient for use cases where a specific prefix is searched in a larger string.
* Cons:
	+ May not be suitable for all use cases, such as searching for a substring anywhere in the string.

### 3. `indexOf starts`

```json
"Benchmark Definition": "const str = \"https://firebasestorage.googleapis.com/v0/b/a-sketch-a-day-207420.appspot.com/o/\"\r\nstr.indexOf(\"https://fire\") === 0"
```

This benchmark tests the performance of the `indexOf` method with a strict equality check, which returns `0` if the string starts with a specified value.

**Pros and Cons:**

* Pros:
	+ Combines the benefits of both `includes` and `startsWith`.
	+ Efficient for use cases where a specific prefix is searched in a larger string.
* Cons:
	+ May be slower than `startsWith` alone due to the additional equality check.

### 4. `indexOf somewhere`

```json
"Benchmark Definition": "const str = \"https://firebasestorage.googleapis.com/v0/b/a-sketch-a-day-207420.appspot.com/o/\"\r\nstr.indexOf(\"firebasestorage\") > -1"
```

This benchmark tests the performance of the `indexOf` method with a non-strict equality check, which returns `true` if the string contains a specified value anywhere.

**Pros and Cons:**

* Pros:
	+ Suitable for use cases where a specific substring is searched in a larger string.
	+ Can be faster than `includes` or `startsWith` for certain inputs.
* Cons:
	+ May not be suitable for all use cases, such as searching for a prefix.
	+ Less efficient than `startsWith` for prefixes.

**Library: None**

There are no libraries used in these benchmarks. The methods being tested are built-in JavaScript string methods.

**Special JS Features or Syntax: None**

There are no special JavaScript features or syntax mentioned in the benchmark definitions.

**Other Alternatives**

Other alternatives to these benchmarked methods include:

* Using a regular expression instead of `includes` or `startsWith`
* Using a substring search algorithm, such as Knuth-Morris-Pratt or Boyer-Moore
* Using a more advanced string searching library or framework

Keep in mind that the performance differences between these methods may vary depending on the specific use case and input data.

Latest run results:

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

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

Browser/OS: Chrome 84 on Windows

View result in a separate tab

Test name	Executions per second
includes	39012628.0 Ops/sec
startsWith	26160034.0 Ops/sec
indexOf starts	918712256.0 Ops/sec
indexOf somewhere	921924928.0 Ops/sec

Related benchmarks:

startswith vs includes3 (version: 0)

Comparing performance of: includes vs startsWith vs indexOf starts vs indexOf somewhere

Created: 4 years ago by: Guest

Jump to the latest result

includes

startsWith

indexOf starts

indexOf somewhere

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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