Benchmark: str.match vs - MeasureThat.net

Script Preparation code:

str = "1875 Tokens";
re = /(\d+)\sTokens/;

Tests:

String.split
str.split(" ")[0]
String.match
str.match(re)[0]
Regex.exec
re.exec(str)[1]
String.replace
str.replace(' Tokens', '')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String.split
String.match
Regex.exec
String.replace

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 109 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
String.split	2652683.8 Ops/sec
String.match	1833713.5 Ops/sec
Regex.exec	1882779.9 Ops/sec
String.replace	2565991.2 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 benchmark and explain what is being tested, compared, and analyzed.

**Benchmark Definition**

The benchmark is defined by two JSON objects:

1. The top-level object represents a single test case, which includes:
	* `Name`: a human-readable name for the test case (e.g., "str.match vs ")
	* `Description`: a brief explanation of what the test case is measuring
	* `Script Preparation Code` and `Html Preparation Code`: these are snippets of JavaScript code that set up the environment for the test case. In this case, they define two strings: `str` with the value "1875 Tokens" and regular expression `re` with the pattern `(\\d+)\\sTokens`.
2. The second JSON object represents an array of individual test cases:
	* Each test case includes a `Benchmark Definition` string that defines the operation to be measured (e.g., `"str.split(\" \")[0]"` or `"str.match(re)[0]"`)
	* A unique `Test Name` for each test case

**What is being tested?**

The benchmark tests the performance of four different JavaScript operations:

1. **String Split**: `str.split(" ")[0]`
2. **Regular Expression Matching**: `str.match(re)[0]`
3. **Regex Execution**: `re.exec(str)[1]`
4. **String Replace**: `str.replace(' Tokens', '')`

**Options compared**

The benchmark compares the performance of these four operations on the same input string, which is a single line with multiple tokens separated by spaces.

**Pros and Cons:**

* **String Split**: This operation is generally faster because it uses a built-in method that can handle multiple token separations in a single step. However, if the input string is very large or contains many tokens, this method might be slower due to the overhead of iterating over each token.
* **Regular Expression Matching**: This operation is often slower than String Split because regular expressions are more complex and computationally expensive. However, it provides more flexibility in terms of pattern matching and can handle a wide range of input formats.
* **Regex Execution**: Similar to Regular Expression Matching, this operation is generally slower due to the overhead of executing the regex pattern. However, it might be faster than Regular Expression Matching if the input string contains many matches that can be executed efficiently.
* **String Replace**: This operation is often slower because it involves iterating over each character in the input string and replacing individual tokens. However, it provides a simple way to replace multiple substrings at once.

**Library:**

The benchmark uses the built-in `split` method of JavaScript strings, which is implemented in native code and optimized for performance.

There are no external libraries used in this benchmark.

No special JavaScript features or syntax are used in this benchmark beyond what is typical in everyday JavaScript development.

**Alternatives:**

Other alternatives to measure similar performance benchmarks could include:

* Using a different string separator (e.g., commas, semicolons)
* Adding more tokens to the input string
* Using a different regular expression pattern
* Measuring the performance of other string operations, such as concatenation or substring extraction

Keep in mind that these alternatives may change the results and interpretation of the benchmark, so it's essential to carefully consider the specific requirements and goals of the measurement.

Related benchmarks:

str.match vs (version: 0)

Test String.match with regex against String.split with string. We are splitting a string at the spaces.

Comparing performance of: String.split vs String.match vs Regex.exec vs String.replace

Created: 2 years ago by: Guest

Jump to the latest result

String.split

String.match

Regex.exec

String.replace

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):