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

Latest run results:

Run details: (Test run date: 2 years 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

indexOf (start)

4K/s

indexOf (end)

4K/s

includes (end)

4K/s

includes (start)

4K/s

startsWith (end)

3K/s

startsWith (start)

2K/s

View exact numbers

Test name	Executions per second
✓ indexOf (start)	3,732 Ops/sec
indexOf (end)	3,729 Ops/sec
includes (end)	3,709 Ops/sec
includes (start)	3,705 Ops/sec
startsWith (end)	3,430 Ops/sec
startsWith (start)	2,292 Ops/sec

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

indexOf vs startsWidth vs includes (version: 0) Benchmark.js

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: 2 years ago by: Guest

Go to the latest result

indexOf (start)

indexOf (end)

startsWith (start)

startsWith (end)

includes (start)

includes (end)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

indexOf vs startsWidth vs includes (version: 0) Benchmark.js

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: 2 years ago by: Guest

Go to the latest result

indexOf (start)

indexOf (end)

startsWith (start)

startsWith (end)

includes (start)

includes (end)

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: `indexOf (start) vs indexOf (end) vs startsWith (start) vs startsWith (end) vs includes (start) vs includes (end)`