Benchmark: startswith vs includes

Tests:

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

Historical Performance Data aggregated from 455 community runs

Desktop Results:

Chrome 401 runs

includes

171.7M/s

startsWith

45.3M/s

Fastest: includes (3.8x faster)

View exact numbers

✓ includes: 171,709,472 ops/sec
• startsWith: 45,265,924 ops/sec

Firefox 35 runs

startsWith

1556.4M/s

includes

1550.9M/s

View exact numbers

✓ startsWith: 1,556,397,696 ops/sec
• includes: 1,550,883,712 ops/sec

Safari 13 runs

startsWith

67.7M/s

includes

42.4M/s

Fastest: startsWith (1.6x faster)

View exact numbers

✓ startsWith: 67,742,600 ops/sec
• includes: 42,446,336 ops/sec

Mobile Results:

Chrome 6 runs

includes

65.3M/s

startsWith

33.4M/s

Fastest: includes (2.0x faster)

View exact numbers

✓ includes: 65,279,952 ops/sec
• startsWith: 33,381,428 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
startsWith

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

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

Browser/OS: Chrome 149 on Windows

View result in a separate tab

includes

245.2M/s

startsWith

51.3M/s

View exact numbers

Test name	Executions per second
✓ includes	245,173,008 Ops/sec
startsWith	51,281,152 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance can be quite complex, especially when considering the various libraries and features used in modern web development.

**Benchmark Overview**

The provided benchmark measures the performance difference between two string methods: `includes` and `startsWith`. Both methods are part of the ECMAScript standard, but they behave differently.

**Options Compared**

In this benchmark, two options are compared:

1. **`str.includes("firebase")`**: This method checks if a given string ("firebase") is present at the beginning of another string (`str`). It returns `true` if the substring is found, and `false` otherwise.
2. **`str.startsWith("https://firebase")`**: This method checks if a given string ("https://firebase") is equal to the beginning of another string (`str`). It returns `true` if the substring matches, and `false` otherwise.

**Pros and Cons**

1. **`includes` method:**
	* Pros:
		+ More flexible, as it can search for any part of the string within a larger context.
		+ Can be faster for larger strings, since it only needs to iterate through a portion of the string.
	* Cons:
		+ Less efficient when searching for an exact match at the beginning of the string.
2. **`startsWith` method:**
	* Pros:
		+ More efficient when searching for an exact match at the beginning of the string.
		+ Can be faster for smaller strings, since it only needs to compare a short substring.
	* Cons:
		+ Less flexible than `includes`, as it can only search for an exact match.

**Library Usage**

There is no explicit library usage in this benchmark. However, both methods rely on the JavaScript engine's implementation of string matching algorithms.

**Special JS Features or Syntax**

This benchmark does not involve any special JavaScript features or syntax beyond the standard `includes` and `startsWith` methods.

**Other Alternatives**

If you're looking for alternatives to these string methods, consider:

1. **Using a regular expression**: You can use the `RegExp` object to search for patterns in strings using regular expressions. This approach is more flexible than both `includes` and `startsWith`, but it may be slower due to the overhead of compiling and executing the regex pattern.
2. **Manual string searching**: If you need extreme performance, you could implement a simple manual string searching algorithm using bitwise operations or other low-level techniques.

In general, for most web development use cases, the standard `includes` and `startsWith` methods are sufficient and efficient enough. However, if you have specific requirements that necessitate more flexibility or performance, consider exploring regular expressions or alternative algorithms.

startswith vs includes (version: 0)

Comparing performance of: `includes vs startsWith`

Created: 5 years ago by: Guest

Go to the latest result

includes

startsWith

Historical Performance Data aggregated from 455 community runs

Desktop Results:

Chrome 401 runs

Firefox 35 runs

Safari 13 runs

Mobile Results:

Chrome 6 runs

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 includes (version: 0)

Comparing performance of: includes vs startsWith

Created: 5 years ago by: Guest

Go to the latest result

includes

startsWith

Historical Performance Data aggregated from 455 community runs

Desktop Results:

Chrome 401 runs

Firefox 35 runs

Safari 13 runs

Mobile Results:

Chrome 6 runs

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: `includes vs startsWith`