Benchmark: r1 v r2 - MeasureThat.net

Script Preparation code:

var str = '124sadf96192586sdf1925asdf69asdf12569qewtq81zxcv25';
var r1 = /\D/g;
var r2 = /\D+/g;

Tests:

r1
str.replace(r1, '');
r2
str.replace(r2, '');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
r1
r2

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to explain what's being tested in the provided JSON benchmark.

**Benchmark Definition**
The benchmark defines two test cases, "r1" and "r2", which are used to measure the performance of JavaScript regular expressions (regex) in removing non-printable characters (`\\D`) from a given string. The script preparation code is a simple example that creates two regex patterns, `r1` and `r2`, using forward slashes (`/`) and capturing all non-printable characters (`\\D+`). The HTML preparation code is empty.

**Options Compared**
The benchmark compares the performance of `str.replace(r1, '')` (test case "r1") against `str.replace(r2, '')` (test case "r2"). Both tests use the same input string (`str`) and measure the number of executions per second.

**Pros and Cons of Different Approaches**

* **Using forward slashes (/)**: This is a common way to write regex patterns in JavaScript. The pros are that it's widely supported and easy to read. However, the cons are that it can lead to issues with Unicode support and may cause performance problems if not used carefully.
* **Using a capture group (\\D+)**: Using a capture group can improve performance by reducing the number of lookups required in the regex engine. The pros are that it's efficient for this specific use case, where we only need to match non-printable characters. However, the cons are that it may be less readable and more prone to errors if not used carefully.
* **Using `replace()`**: The `replace()` method is a built-in JavaScript function that replaces substrings with new values. The pros are that it's easy to use and doesn't require manual regex pattern writing. However, the cons are that it may be slower than using regex patterns directly and can lead to issues if not used carefully.

**Library: RegExp**
The `RegExp` object is a built-in JavaScript class that provides support for regular expressions. It's used in this benchmark to create the regex patterns `r1` and `r2`. The `RegExp` object has various methods, such as `test()`, `exec()`, and `replace()`, which can be used to work with regex patterns.

**Special JS Feature/Syntax**
There is no special JavaScript feature or syntax being tested in this benchmark. It's a straightforward test of regular expression performance.

**Other Alternatives**
If you want to write similar benchmarks, you could consider using other JavaScript testing frameworks like Jest or Mocha. Alternatively, you could also use existing benchmarking tools like Benchmark.js or jsperf.

Keep in mind that the choice of approach and library may vary depending on your specific use case and requirements.

Latest run results:

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

User agent: Mozilla/5.0 (iPad; CPU OS 10_0_1 like Mac OS X) AppleWebKit/602.1.50 (KHTML, like Gecko) Version/10.0 Mobile/14A403 Safari/602.1

Browser/OS: Mobile Safari 10 on iOS 10.0.1

View result in a separate tab

Test name	Executions per second
r1	1532247.9 Ops/sec
r2	2025161.5 Ops/sec

Related benchmarks:

r1 v r2 (version: 0)

Comparing performance of: r1 vs r2

Created: 8 years ago by: Guest

Jump to the latest result

r1

r2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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