Benchmark: regex performance with search

Script Preparation code:

var html = "<p>A</p><table><tr><td>1</td><td>2</td></tr></table><p>B</p>";

Tests:

test
/<table\b[^>]*>/i.test(html)
exec
/<table\b[^>]*>/i.exec(html)
match
html.match(/<table\b[^>]*>/i)
indexOf
html.toLowerCase().indexOf('<table')
search
html.search(/<table\b[^>]*>/i)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
test
exec
match
indexOf
search

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 90 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
test	9124243.0 Ops/sec
exec	7598622.0 Ops/sec
match	7244513.0 Ops/sec
indexOf	17055356.0 Ops/sec
search	8908225.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is being tested?**

The provided benchmark tests the performance of different regular expression (regex) methods in JavaScript for searching and finding a specific pattern in a string, in this case, a table element (`<table>`) within an HTML string.

**Options compared:**

1. `i.test(html)` - This method tests if the specified regex pattern exists at the end of the search.
2. `i.exec(html)` - This method executes the regex pattern on the search string and returns an array with match data if found.
3. `html.match(/<table\\b[^>]*>/i)` - This uses the built-in `String.prototype.match()` method to find all occurrences of the regex pattern in the string.
4. `html.toLowerCase().indexOf('<table')` - This uses the `String.prototype.indexOf()` method with a lowercased version of the search string, looking for the first occurrence of the specified substring.
5. `html.search(/<table\\b[^>]*>/i)` - This method searches for the regex pattern in the string and returns the index of the match (0 if not found).

**Pros and cons of each approach:**

1. **`i.test(html)`**: Pros:
	* Fast and efficient, as it only checks for existence at the end of the search.
	* Lightweight, as it doesn't require creating a regex pattern object.
	Cons:
	* Returns `true` if the pattern exists anywhere in the string, not just at the end.
2. **`i.exec(html)`**: Pros:
	* Can return an array with match data, which might be useful for further processing.
	Cons:
	* May return null or undefined if no matches are found, and can be slower than `test()` due to additional overhead.
3. **`html.match(/<table\\b[^>]*>/i)`**: Pros:
	* Returns all occurrences of the regex pattern in the string as an array.
	Cons:
	* Can be slower and more memory-intensive due to creating an array with multiple matches.
4. **`html.toLowerCase().indexOf('<table')`**: Pros:
	* Simple, easy-to-understand approach using a built-in method.
	Cons:
	* Returns the index of the first occurrence of the specified substring (case-sensitive).
5. **`html.search(/<table\\b[^>]*>/i)`**: Pros:
	* Similar to `test()`, but returns the index of the match instead of just a boolean value.

**Library and its purpose:**

In this benchmark, the `String.prototype.match()` method is used in the "match" test case. This method takes two arguments: a regex pattern and a string to search for the pattern. It returns an array containing any matches found in the string, or null if no matches are found.

**Special JS feature or syntax:**

In this benchmark, the `\\b` special sequence is used within the regex patterns. `\b` is a word boundary that matches either the empty string (at the beginning or end of a word) or any single character that is not alphanumeric. This helps improve performance by avoiding partial word matches.

**Alternatives:**

If you need to search for regular expressions in strings, other alternatives might include:

1. Using `String.prototype.replace()` with a regex pattern and a replacement function.
2. Utilizing third-party libraries like RegEx (for more advanced regex functionality) or a dedicated regex engine like Uregex.
3. Implementing custom search algorithms, such as using Boyer-Moore or Knuth-Morris-Pratt algorithms for optimized string matching.

These alternatives might offer better performance, more features, or flexibility depending on your specific use case and requirements.

Related benchmarks:

regex performance with search (version: 0)

Comparing performance of: test vs exec vs match vs indexOf vs search

Created: 4 years ago by: Guest

Jump to the latest result

test

exec

match

indexOf

search

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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