Benchmark: RegEx.test vs. String.includes vs. String.match vs Array.includes

Script Preparation code:

var string = "Hello world!";
var regex = /Hello/;
var array = [string]

Tests:

RegEx.test
regex.test(string);
String.includes
string.includes("Hello");
String.match
string.match("Hello");
Array.includes
array.includes("Hello")

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
String.includes
String.match
Array.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/110.0.0.0 Safari/537.36 Edg/110.0.1587.63

Browser/OS: Chrome 110 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	6370908.0 Ops/sec
String.includes	16498731.0 Ops/sec
String.match	3776949.5 Ops/sec
Array.includes	16859558.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark and explain what is being tested.

**Overview**

The benchmark compares the performance of three different approaches to check if a substring exists in a string:

1. `RegEx.test()`: This method uses regular expressions to search for a match in the string.
2. `String.includes()`: This method checks if a substring exists in the string using a simple iteration.
3. `String.match()`: This method returns an array containing all matches of the pattern in the string, or null if no match is found.

The benchmark also compares the performance of searching for a match in an array using `Array.includes()`.

**Options Compared**

* Regular expressions (`RegEx.test()`) vs. simple iteration (`String.includes()`)
* Regular expressions (`RegEx.test()`) vs. pattern matching (`String.match()`)
* Simple iteration (`String.includes()`) vs. pattern matching (`String.match()`)
* Searching in a string (`String.includes()` and `String.match()`) vs. searching in an array (`Array.includes()`)

**Pros and Cons**

* **Regular expressions (RegEx.test())**:
	+ Pros: Can match complex patterns, can be used for both searching and replacing.
	+ Cons: Can be slow due to the complexity of the pattern, may require more memory.
* **Simple iteration (String.includes())**:
	+ Pros: Fast, lightweight, easy to implement.
	+ Cons: Only works for exact matches, may not handle edge cases well.
* **Pattern matching (String.match())**:
	+ Pros: Can match complex patterns, returns all matches.
	+ Cons: Returns an array of matches, which can be memory-intensive. May require more code to process the results.
* **Searching in an array (Array.includes())**:
	+ Pros: Fast and lightweight, easy to implement.
	+ Cons: Only works for searching in arrays, may not handle edge cases well.

**Library Usage**

In this benchmark, no libraries are explicitly mentioned. However, it is implied that the `String` object has been modified to include custom methods (`RegEx.test()`).

**Special JS Features or Syntax**

The only special feature used in this benchmark is regular expressions (RegEx). Regular expressions provide a powerful way to match complex patterns in strings.

Overall, this benchmark provides a useful comparison of different approaches to searching for substrings in JavaScript. It can help developers understand the trade-offs between using regular expressions, simple iteration, and pattern matching.

Related benchmarks:

RegEx.test vs. String.includes vs. String.match vs Array.includes (version: 0)

Comparing performance of: RegEx.test vs String.includes vs String.match vs Array.includes

Created: one year ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

Array.includes

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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