Benchmark: tests-regex-for - MeasureThat.net

HTML Preparation code:

var str = "Subject: qqq<br />\nName: qqq<br />\nEmail: 1@test.ru<br />\n<br />\nsdfadf"

Script Preparation code:

var str = "Subject: qqq<br />\nName: qqq<br />\nEmail: 1@test.ru<br />\n<br />\nsdfadf"

Tests:

regex
const regExp = /Subject: (.*) \nName: (.*) \nEmail: (.*) \n \n(.*)/gim; const result = regExp.exec(str) const subject = result[1]; const name = result[2]; const email = result[3]; const description = result[4];
for
const data = str.split(` \n`); let subject; let name; let email; let description; let ticket; data.forEach(item => { const subjectTitle = "Subject: "; const nameTitle = "Name: "; const emailTitle = "Email: "; if(item.indexOf(subjectTitle) !== -1) { subject = item.slice(subjectTitle.length); } if(item.indexOf(nameTitle) !== -1) { name = item.slice(nameTitle.length); } if(item.indexOf(emailTitle) !== -1) { email = item.slice(emailTitle.length); } if( (item.indexOf(subjectTitle) === -1) && (item.indexOf(nameTitle) === -1) && (item.indexOf(emailTitle) === -1) && (item !== "") ) { description = item; } });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regex
for

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its options.

**Benchmark Definition**

The benchmark is designed to measure the performance of two different approaches: regular expressions (regex) and a loop-based approach using the `split()` method.

**Script Preparation Code**

The script preparation code defines a string variable `str` containing HTML data with email addresses. The string contains:

* A subject line
* A name
* An email address
* A description

This data is used to create two test cases: one using regex and the other using a loop-based approach.

**Html Preparation Code**

The html preparation code is identical to the script preparation code, as it's not being used in this benchmark.

**Individual Test Cases**

There are two test cases:

1. **regex**: This test case uses regular expressions to extract the email address from the input string `str`. The regex pattern `/Subject: (.*) \\nName: (.*) \\nEmail: (.*) \\n \\n(.*)/gim;` is used to capture groups for subject, name, email, and description. The `exec()` method is then called on the regex object with the input string `str`, and the captured values are extracted.
2. **for**: This test case uses a loop-based approach to extract the email address from the input string `str`. It splits the string into individual lines using ` \\n` and iterates through each line. For each line, it checks if the line contains specific keywords (subject, name, email) and extracts the corresponding value using slicing.

**Options Compared**

The two test cases compare the performance of regular expressions versus a loop-based approach for extracting email addresses from HTML data.

**Pros and Cons**

**Regex Approach:**

Pros:

* Often more concise and readable than loop-based approaches
* Can be optimized for performance with features like caching, memoization, or lazy evaluation

Cons:

* Can be slower due to overhead from regex compilation and execution
* May require additional resources (e.g., memory) for large datasets

**Loop-Based Approach:**

Pros:

* Often faster due to simpler iteration and fewer overheads
* Can be more efficient for large datasets, as it avoids the overhead of regex compilation

Cons:

* Can be less readable or maintainable than regex approaches
* Requires explicit management of data structures (e.g., arrays) and loop logic

**Other Considerations**

When choosing between these two approaches, consider the trade-offs between performance, readability, and maintainability. For small datasets or simple use cases, a regex approach might be sufficient. However, for larger datasets or complex data extraction scenarios, a loop-based approach might offer better performance.

In this benchmark, the latest results show that the `regex` test case has slightly better performance on Chrome 103, while the `for` test case has better performance on another device (not shown in the results).

**Alternative Approaches**

Other approaches for extracting email addresses from HTML data include:

* Using a dedicated library like cheerio or jsdom
* Utilizing browser-specific APIs (e.g., Chrome's content script API)
* Implementing custom parsing logic using DOM manipulation and string slicing

Each approach has its pros and cons, and the choice ultimately depends on the specific requirements of your project.

Related benchmarks:

tests-regex-for (version: 0)

-

Comparing performance of: regex vs for

Created: 5 years ago by: Guest

Jump to the latest result

regex

for

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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