Benchmark: Asterisk character test

Script Preparation code:

var string = "*\n\u001e\rA*SI 6*6014*5000*DL00*1019*ZC02*7000*DLDA*I123*568\n*CSLA*TNAM*\nDDE*\nDAC*ARIA*DDFN*DAD\n*DGN\n*CAC\n*CBNO*E   *  \nD*DNON* \nDB*0831*009\n*BB01*1198*\nDBA*8312*24\nD*C2\nD*U065*n\nDA*BRN\n*AG60* B S*\nDAI*AN D*EGO\n*AJCA*DAK9*101 *    *DCF\n*CGUS*\rZCZ*A01\r";
var regex = /A*SI/;

Tests:

RegEx.test
regex.test(string);
String.includes
string.includes("A*SI");
String.match
string.match("A*SI");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
String.includes
String.match

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases.

**Benchmark Definition**

The benchmark is measuring the performance of three different approaches for searching or checking if a specific string exists within another string: `regex.test()`, `string.includes()`, and `string.match()`.

**Test Cases**

1. **RegEx.test**: This test case uses the `RegExp` object's `test()` method, which attempts to match the regular expression against the entire input string.
2. **String.includes**: This test case uses the `includes()` method, which checks if a specified value exists within a given string.
3. **String.match**: This test case uses the `match()` method, which searches for a regular expression in a string and returns an array of matches.

**Library Used: RegExp**

The `RegExp` object is used in the first test case (`RegEx.test`). The `RegExp` object provides a way to search for a pattern in a string. In this case, it's using a regular expression to match against the input string `string`.

**JavaScript Features/Syntax Used**

* None explicitly mentioned, but note that this benchmark is focused on the performance of these specific methods and does not delve into more advanced JavaScript features.

**Comparison Options: Pros and Cons**

The three methods have different approaches to searching or checking if a string exists within another:

1. **RegExp.test()**:
	* Pros: Can perform complex searches, supports negative lookaheads and assertions, and can be optimized for performance.
	* Cons: Can be slower than other methods due to its use of regular expressions and the overhead of compiling the regex pattern.
2. **String.includes()**:
	* Pros: Fast and efficient, as it uses a simple string comparison algorithm.
	* Cons: May not support complex searches or regular expressions, which can lead to slower performance for certain use cases.
3. **String.match()**:
	* Pros: Supports regular expressions, which can be useful for more complex searches.
	* Cons: Can be slower than `includes()` due to the overhead of compiling and executing the regex pattern.

**Other Alternatives**

If you need faster or more efficient string matching, consider using:

1. **Array.prototype.includes()**: Similar to `String.includes()`, but optimized for arrays.
2. **String.prototype.startsWith()** and **String.prototype.endsWith()**: Can be used in combination with `includes()` to check if a string starts with or ends with a certain substring.
3. **Regular expression APIs**: If you need more advanced features, consider using dedicated regular expression libraries like `lodash.regex` or `regex-js`.

Keep in mind that the choice of method ultimately depends on your specific use case and performance requirements.

For this benchmark, MeasureThat.net is providing a controlled environment for developers to compare the performance of these three methods. By running multiple executions per second, the benchmark provides a comprehensive picture of each method's performance under different conditions.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 109 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
RegEx.test	6606964.5 Ops/sec
String.includes	15531135.0 Ops/sec
String.match	3557872.2 Ops/sec

Related benchmarks:

Asterisk character test (version: 0)

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

Created: one year ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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