Benchmark: indexOf vs regex vs RegExp

Script Preparation code:

var str = "This is a simple test!";
var needle = "simple";
var ri = new RegExp('simple', 'i');

Tests:

lowercase, trim, indexof
var a = str.toLowerCase().trim(); var b = needle.toLowerCase().trim(); var c = a.indexOf(b) > -1;
trim, lowercase, indexof
var a = str.trim().toLowerCase(); var b = needle.trim().toLowerCase(); var c = a.indexOf(b) > -1;
regex
var c = /simple/i.test(str);
lowercase, replace, indexof
var a = str.toLowerCase().replace(" ", ""); var b = needle.toLowerCase().replace(" ", ""); var c = a.indexOf(b) > -1;
RegExp
var c = (new RegExp(needle, 'i')).test(str);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lowercase, trim, indexof
trim, lowercase, indexof
regex
lowercase, replace, indexof
RegExp

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0

Browser/OS: Firefox 122 on Windows

View result in a separate tab

Test name	Executions per second
lowercase, trim, indexof	8443965.0 Ops/sec
trim, lowercase, indexof	9247242.0 Ops/sec
regex	13267128.0 Ops/sec
lowercase, replace, indexof	3598908.0 Ops/sec
RegExp	3870165.2 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 benchmark and explain what's being tested.

The provided JSON represents a JavaScript microbenchmark, specifically testing different methods for finding an occurrence of a substring within a string. The three main approaches being compared are:

**1. `indexOf()` method**

The `indexOf()` method returns the index of the first occurrence of the specified value, or -1 if it's not found. This approach is straightforward and widely supported in JavaScript.

Pros: Simple to implement, fast execution.

Cons: May be slower for certain edge cases, like searching for a substring at the beginning of the string.

**2. `RegExp` object**

The `RegExp` object allows you to create a regular expression pattern to search for a specific value within a string. In this benchmark, the `i` flag makes the search case-insensitive.

Pros: Flexible and powerful for complex search patterns, can handle edge cases efficiently.

Cons: May be slower than simple `indexOf()` calls due to the overhead of creating and compiling the regular expression pattern.

**3. String replacement (e.g., `toLowerCase().replace()`)**

This approach involves converting both the input string and the search value to lowercase before searching for the substring. The `replace()` method is then used to replace any occurrences with an empty string, effectively counting matches.

Pros: Can be faster than using regular expressions for simple cases, as it avoids overhead of creating patterns.

Cons: May not handle edge cases correctly (e.g., case-insensitive search), and can lead to unnecessary work when dealing with strings that don't contain the search value.

In this benchmark, each test case is designed to compare one approach against another. For example:

* `lowercase, trim, indexof` compares using `toLowerCase()` and `trim()` followed by the `indexOf()` method.
* `trim, lowercase, indexof` does a similar comparison but reverses the order of the two string operations.

The benchmark results show that different browsers (in this case, Firefox 122) execute each test case at varying speeds. The fastest execution times are observed for the `regex` approach in Firefox 122.

Now, let's take a look at some specific library usage:

* None is explicitly mentioned in the provided JSON, but it's worth noting that other libraries or modules (e.g., Lodash) might be used to implement these benchmark cases.
* No special JavaScript features or syntax are mentioned, so we can assume this benchmark focuses on standard JavaScript functionality.

Other alternatives for implementing similar benchmarks could include:

* Using a library like `regex-trie` for efficient substring searching.
* Implementing custom implementations using bit manipulation techniques (e.g., Boyer-Moore algorithm).
* Comparing different caching strategies or optimizations to improve performance.
* Adding additional edge cases, such as Unicode support or handling multiple search values simultaneously.

Keep in mind that the specific choice of alternatives depends on the desired outcome and requirements for your benchmark.

Related benchmarks:

indexOf vs regex vs RegExp (version: 0)

Comparing performance of: lowercase, trim, indexof vs trim, lowercase, indexof vs regex vs lowercase, replace, indexof vs RegExp

Created: 5 years ago by: Guest

Jump to the latest result

lowercase, trim, indexof

trim, lowercase, indexof

regex

lowercase, replace, indexof

RegExp

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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