Benchmark: IndexOf vs Includes in string as boolean

Script Preparation code:

var string = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.'

Tests:

IndexOf > -1
string.indexOf('tempor') > -1
Includes
string.includes('tempor')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
IndexOf > -1
Includes

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
IndexOf > -1	227016320.0 Ops/sec
Includes	217374704.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to explain what's tested in the provided benchmark.

**Benchmark Overview**

The benchmark tests two different approaches to check if a substring exists within a given string: `string.includes()` and `string.indexOf()`. The benchmark compares these two approaches to measure their performance difference.

**Approaches Compared**

1. **`string.includes()`**: This method returns `true` if the string includes the specified value, otherwise it returns `false`.
2. **`string.indexOf()`**: This method returns the index of the first occurrence of the specified value in the string, or `-1` if not found.

**Pros and Cons**

*   **`string.includes()`**:
    *   Pros:
        *   More concise and readable syntax.
        *   Less prone to errors due to its simple boolean return type.
    *   Cons:
        *   May be slower than `indexOf()` for large strings, as it uses a more complex algorithm that searches the entire string from left to right.

*   **`string.indexOf()`**:
    *   Pros:
        *   Faster than `includes()`, especially for large strings, since it only searches the substring of interest.
        *   Returns the actual index of the found value if present, which can be useful in certain contexts.
    *   Cons:
        *   Less readable and more error-prone due to its more complex syntax.

**Special Considerations**

The benchmark uses a `string` variable that contains a long string with the text "tempor" embedded within it. This is likely chosen for its length, which affects the performance of both methods.

The use of `Firefox 99` and `Windows` as the browser and operating system, respectively, may be relevant if the benchmark aims to isolate platform-specific performance differences.

**Library Usage**

None of the provided benchmark scripts explicitly uses any external JavaScript libraries beyond what's already part of the standard library (ECMAScript). The `string` variable is a built-in type that doesn't require additional setup or dependencies.

However, if we consider the context in which these methods are used, it's worth noting that other libraries might utilize optimized implementations for specific use cases. Nonetheless, within the scope of this benchmark, both approaches rely solely on the standard library functions.

**Alternative Approaches**

Other alternatives to `string.includes()` and `string.indexOf()` include:

*   Using a regular expression engine (e.g., `RegExp.test()`) with a search pattern that matches the target substring.
*   Employing a custom algorithm for searching substrings within strings.
*   Leveraging built-in string methods like `startsWith()` and `endsWith()` instead, although these may not directly address the problem at hand.

In terms of performance optimizations, some approaches might consider utilizing:

*   Advanced indexing techniques or data structures (e.g., hash tables, trie-based search) to improve lookup efficiency.
*   Caching results from previous searches or using memoization to store intermediate results.
*   Optimizing code for specific use cases, such as minimizing overhead or exploiting browser-specific features.

However, these optimizations would typically be platform-specific and context-dependent, making them less relevant in this straightforward benchmark scenario.

Related benchmarks:

IndexOf vs Includes in string as boolean (version: 0)

Banana

Comparing performance of: IndexOf > -1 vs Includes

Created: 4 years ago by: Guest

Jump to the latest result

IndexOf > -1

Includes

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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