Benchmark: startsWith vs includes vs search

Tests:

startsWith
var a = "/articles/this-that-other-outre-collection" var b = a.startsWith('/articles');
includes
var a = "/articles/this-that-other-outre-collection" var b = a.includes('articles',1);
search
var a = "/articles/this-that-other-outre-collection" var b = a.search('articles');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
startsWith
includes
search

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
startsWith	105151208.0 Ops/sec
includes	231175744.0 Ops/sec
search	12912043.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

This benchmark compares three methods available in JavaScript for determining whether a string contains another substring: `startsWith`, `includes`, and `search`. Here’s a breakdown of each method being tested, along with their pros and cons.

### 1. `startsWith`

**Definition:**  
The `startsWith` method checks if a given string starts with the characters of a specified string. It returns `true` if it does, otherwise `false`.

**Test Case:**  
```javascript
var a = "/articles/this-that-other-outre-collection"; 
var b = a.startsWith('/articles');
```

**Pros:**
- **Simplicity:** It's straightforward when checking the beginning of a string.
- **Performance:** Typically faster than methods that require full substring search because it checks just the starting portion.

**Cons:**
- **Limited Use Case:** Only checks for the beginning of the string not versatile for finding substrings situated anywhere within the string.

### 2. `includes`

**Definition:**  
The `includes` method determines whether one string may be found within another string, returning `true` or `false` as appropriate. It can also accept a second parameter to specify the position at which to start the search.

**Test Case:**
```javascript
var a = "/articles/this-that-other-outre-collection"; 
var b = a.includes('articles', 1);
```

**Pros:**
- **Versatility:** Can check if a substring exists anywhere within the string.
- **Clarity:** More descriptive and often easier to understand its intention than some alternatives.

**Cons:**
- **Performance:** While generally fast, it may be slower than `startsWith` for shorthand checks, as it evaluates the entire string rather than just the beginning.
- **Position Limitations:** The second argument is not intuitive for some use cases, leading to potential confusion.

### 3. `search`

**Definition:**  
The `search` method executes a search for a match between a regular expression and this String object. It returns the index of the match, or -1 if the search fails.

**Test Case:**
```javascript
var a = "/articles/this-that-other-outre-collection"; 
var b = a.search('articles');
```

**Pros:**
- **Power of Regular Expressions:** Allows more complex matching patterns using regex, which can be incredibly powerful for advanced search cases.
- **Return Value:** Provides the index of the first match, which can be useful in certain scenarios.

**Cons:**
- **Complexity and Performance:** The use of regular expressions can be more complex and slower than both `includes` and `startsWith`.
- **Overkill for Simple Checks:** For simple substring checks, using `search` may be unnecessarily complicated and less performant.

### Benchmark Results Summary

The benchmark test results indicate that the `includes` method performed the best in terms of executions per second (231,175,744), followed by `startsWith` (105,151,208). The `search` method lagged significantly behind at 12,912,043 executions per second. This suggests that while all methods have their use cases, `includes` and `startsWith` are more efficient for simple containment checks in contrast to `search`, which is better suited for more complex regex operations.

### Other Alternatives
- **`indexOf`**: This older method checks if a substring is found within a string. It returns the index of the substring or -1 if not found. While still usable, it is less preferable to `includes` for readability.
- **Regular Expressions**: Besides using `search`, regex can also be applied with string methods like `match` or `replace` for more complex matching needs.

### Conclusion
Choosing between `startsWith`, `includes`, and `search` largely depends on your specific requirements. For simple beginning checks, prefer `startsWith`. If you need to check for inclusion anywhere in the string, `includes` is preferred for its performance and clarity. Reserve the use of `search` for scenarios that require more complex substring matching using regex.

Related benchmarks:

startsWith vs includes vs search (version: 0)

Comparing performance of: startsWith vs includes vs search

Created: 2 months ago by: Guest

Jump to the latest result

startsWith

includes

search

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):