Benchmark: regex 0001 - MeasureThat.net

Script Preparation code:

var REGEX_1 = /"{0,1}cpf"{0,1}[:=]"{0,1}([\w\s]{1,})/;
var REGEX_2 = /"{0,1}cpf"{0,1}[:=]\"{0,1}([\w\s]+)/;

Tests:

REGEX_1
REGEX_1.test("cpf=123")
REGEX_2
REGEX_2.test("cpf=123")

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
REGEX_1
REGEX_2

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36

Browser/OS: Chrome 95 on Linux

View result in a separate tab

Test name	Executions per second
REGEX_1	10495010.0 Ops/sec
REGEX_2	10335658.0 Ops/sec

Autogenerated LLM Summary (model llama3.1:latest, generated 2 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the explanation of what is being tested and compared on MeasureThat.net.

**Benchmark Definition**

The benchmark definition represents two different regular expression (regex) patterns, `REGEX_1` and `REGEX_2`. The preparation code creates these regex patterns and stores them in variables `REGEX_1` and `REGEX_2`.

```javascript
var REGEX_1 = /"{0,1}cpf"{0,1}[:=]"{0,1}([\w\s]{1,})"/;
var REGEX_2 = /"{0,1}cpf"{0,1}[:=\]"{0,1}([\w\s]+)//;
```

**Test Cases**

Two test cases are defined: `REGEX_1.test("cpf=123")` and `REGEX_2.test("cpf=123")`. These test cases execute the two regex patterns on a sample string `"cpf=123"`.

**What is being tested?**

In this benchmark, we're comparing the performance of two different regex patterns when executed on a sample string. The goal is to determine which pattern is faster in terms of executions per second (EPS).

**Options compared:**

* `REGEX_1`: This pattern uses a more verbose syntax with escaped quotes (`"`) and character classes (`\w` and `\s`). It also includes a capturing group (`([\\w\\s]{1,})`).
* `REGEX_2`: This pattern uses a slightly different syntax with single quotes (`'`) instead of double quotes. It also omits the capturing group.

**Pros and Cons:**

* `REGEX_1`: More verbose syntax may make it easier to read and maintain for developers who are familiar with regex patterns. However, this verbosity can also lead to slower performance due to the extra overhead of parsing the more complex pattern.
* `REGEX_2`: The simplified syntax may result in faster execution times since it's less computationally expensive to parse. However, this brevity comes at the cost of reduced readability for developers who are not familiar with regex patterns.

**Library and Special JS Feature:**

No libraries or special JavaScript features are used in this benchmark.

**Alternatives:**

If you're concerned about performance when using regular expressions, consider the following alternatives:

1. **String methods:** Instead of using regex patterns, use built-in string methods like `indexOf()` or `includes()`, which can be more efficient for simple string matching tasks.
2. **Regex optimization:** If you must use regex patterns, try optimizing them by minimizing unnecessary escapes and character classes.
3. **Pre-compilation:** Some libraries and frameworks allow pre-compiling regex patterns to improve performance.

Overall, this benchmark provides insights into the performance differences between two distinct regex patterns. While the results may vary depending on your specific use case, they can help guide decisions when choosing between these alternatives.

Related benchmarks:

regex 0001 (version: 0)

Comparing performance of: REGEX_1 vs REGEX_2

Created: 2 years ago by: Guest

Jump to the latest result

REGEX_1

REGEX_2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated 2 months ago):