Benchmark: indexOf vs startsWidth vs includes

Script Preparation code:

var sub = "(sub)";
var textsStart = [];
var textsEnd = [];
for(var i = 0; i < 10000; i++) {
  textsStart.push(`${sub} My ${i} test sample which contains sub at the end`)
  textsEnd.push(`My ${i} test sample which contains sub at the end ${sub}`)
}

Tests:

indexOf (start)
for(const textStart of textsStart) textStart.indexOf(sub)
indexOf (end)
for(const textEnd of textsEnd) textEnd.indexOf(sub)
startsWith (start)
for(const textStart of textsStart) textStart.startsWith(sub)
startsWith (end)
for(const textEnd of textsEnd) textEnd.startsWith(sub)
includes (start)
for(const textStart of textsStart) textStart.includes(sub)
includes (end)
for(const textEnd of textsEnd) textEnd.includes(sub)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf (start)
indexOf (end)
startsWith (start)
startsWith (end)
includes (start)
includes (end)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Purpose**

The purpose of this benchmark is to compare the performance of three different string matching options in JavaScript: `indexOf`, `startsWith`, and `includes`. These options are used to search for a specific substring within a larger string. The benchmark aims to measure which option is the fastest among the three, considering various scenarios where the substring can appear at the start or end of the original string.

**Options Compared**

1. **`indexOf`**: This method searches for the first occurrence of the specified value (the substring) in the string. It returns the index of the first character of the matched substring, or -1 if no match is found.
2. **`startsWith`**: This method checks whether the string starts with the specified value (the substring).
3. **`includes`**: This method checks whether the string includes the specified value (the substring) anywhere within it.

**Pros and Cons of Each Approach**

1. `indexOf`:
	* Pros: Generally fast, efficient, and widely supported.
	* Cons: May not be as effective when searching for substrings at the end of a string, as it returns an index from the beginning of the string.
2. `startsWith`:
	* Pros: Fast and efficient when searching for substrings at the start of a string.
	* Cons: Not suitable for searching substrings in the middle or at the end of a string.
3. `includes`:
	* Pros: Efficiently searches for substrings anywhere within a string, making it suitable for finding substrings that may appear multiple times.
	* Cons: Can be slower than `indexOf` and `startsWith` when searching for single occurrences.

**Library Usage**

None of the tested methods rely on any external libraries. They are all built-in JavaScript methods.

**Special JS Feature or Syntax**

There is no special JavaScript feature or syntax used in this benchmark. The focus is solely on comparing the performance of three standard string matching options.

**Other Alternatives**

If you need to perform string matching operations, other alternatives might include:

1. **RegEx**: Regular expressions offer a powerful way to match patterns within strings, but they can be slower than built-in string methods.
2. **Substring-based approaches**: Implementing custom substring-based searching algorithms can provide optimal performance for specific use cases.

Keep in mind that the choice of method depends on your specific requirements and constraints, such as performance considerations or compatibility with different browsers or environments.

Latest run results:

Run details: (Test run date: 9 months ago)

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

Browser/OS: Chrome 121 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
indexOf (start)	3732.1 Ops/sec
indexOf (end)	3729.3 Ops/sec
startsWith (start)	2292.4 Ops/sec
startsWith (end)	3430.0 Ops/sec
includes (start)	3705.3 Ops/sec
includes (end)	3708.8 Ops/sec

Related benchmarks:

indexOf vs startsWidth vs includes (version: 0)

compare javascript string matching options

Comparing performance of: indexOf (start) vs indexOf (end) vs startsWith (start) vs startsWith (end) vs includes (start) vs includes (end)

Created: 9 months ago by: Guest

Jump to the latest result

indexOf (start)

indexOf (end)

startsWith (start)

startsWith (end)

includes (start)

includes (end)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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