Benchmark: IndexOf vs regex

Script Preparation code:

var uri = 'klcdhhjkdbjkdjbjkb@published';
var uri2 = 'jecdkbbdbkjdbjdbkjdbkjdbkj';
var globalRegex = /@published/;

Tests:

indexOf
uri.indexOf('@published') !== 0; uri2.indexOf('@published') !== 0;
No cached regex
var validRegex = /@published/; validRegex.test(uri); validRegex.test(uri2);
Cached regex
globalRegex.test(uri); globalRegex.test(uri2);
includes
uri.includes('@published'); uri2.includes('@published');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf
No cached regex
Cached regex
includes

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated 29 days ago):

LLMs can make mistakes. Check important info.

This benchmark compares different ways to find the substring "@published" within two example strings: `uri` and `uri2`.  Let's break down each approach:

**1. `indexOf`:**

* **Description:** This method directly uses JavaScript's built-in `indexOf()` function to search for the target string. 
* **Pros:** Simple, concise, likely optimized by the JavaScript engine.
* **Cons:**  Can be slower than regex if you need to perform more complex pattern matching.

**2. `includes`:**

* **Description:** This method utilizes the `includes()` function, introduced in ES6, which checks if a string contains a specific substring.
* **Pros:** Even simpler than `indexOf`, potentially faster for basic substring searches. 
* **Cons:**  Similar limitations to `indexOf` – not suitable for complex pattern matching.

**3.  Regex (`No cached regex`)**:

* **Description:** This test case creates a new regular expression object (`validRegex`) each time it's used to search the strings.
* **Pros:** Regex is powerful for intricate pattern matching. 
* **Cons:** Creating a new regex object on every call can be inefficient as regex compilation takes time.

**4.  Regex (`Cached regex`)**:

* **Description:** This test case uses a pre-compiled regular expression (`globalRegex`) that's defined once and reused for both string searches.
* **Pros:** Much faster than creating new regex objects repeatedly because the pattern is already compiled. 
* **Cons:** Only benefits when you need to search for the same pattern multiple times within your code.

**Other Alternatives:**

* **Libraries (like Underscore or Lodash):** These libraries often provide optimized string manipulation functions, potentially outperforming built-in methods in some cases.

**Key Takeaways:**

*  For simple substring searches, `indexOf` and `includes` are usually the most efficient choices.
* Regex is essential for complex pattern matching, but pre-compile your regexes to avoid performance penalties.

Latest run results:

Run details: (Test run date: 5 years ago)

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

Browser/OS: Chrome 76 on Mac OS X 10.14.0

View result in a separate tab

Test name	Executions per second
indexOf	5813602.0 Ops/sec
No cached regex	3688091.5 Ops/sec
Cached regex	1895945.6 Ops/sec
includes	4029178.2 Ops/sec

Related benchmarks:

IndexOf vs regex (version: 2)

Using indexOf instead of regex to find a sub string

Comparing performance of: indexOf vs No cached regex vs Cached regex vs includes

Created: 6 years ago by: Registered User

Jump to the latest result

indexOf

No cached regex

Cached regex

includes

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated 29 days ago):