Benchmark: regex /g vs / - MeasureThat.net

Tests:

with /g
const envRegex = /\^[a-zA-Z0-9_]+\b/g; const dataRegex = /\$[a-zA-Z0-9_]+\b/g; const dataenvRegex = /(\$|\^)[a-zA-Z0-9_]+\b/g; const eventRegex = /\@[a-zA-Z0-9_]+(?:\.[a-zA-Z0-9_]+|\b)(?:\b\[(#|\.)[a-zA-Z0-9_-]+\]|\b)/g; const str = " background-color: #f7f7f7; opacity: [[ $pageopacity ]]; --r-nonexistentvalue: [[ $noexist ]]; --r-somevar: [[ $somevar ]]; --someevent: [[ @mousemove.clientX[#myelement] ]]; --r-mx: [[ &add(&num(^mouse_clientX), &add(101px,22), 60) ]]px; --r-my: [[ &sub(^mouse_clientY, 20) ]]px;"; str.match(eventRegex);
with /
const envRegex = /\^[a-zA-Z0-9_]+\b/g; const dataRegex = /\$[a-zA-Z0-9_]+\b/g; const dataenvRegex = /(\$|\^)[a-zA-Z0-9_]+\b/g; const eventRegex = /\@[a-zA-Z0-9_]+(?:\.[a-zA-Z0-9_]+|\b)(?:\b\[(#|\.)[a-zA-Z0-9_-]+\]|\b)/g; const str = " background-color: #f7f7f7; opacity: [[ $pageopacity ]]; --r-nonexistentvalue: [[ $noexist ]]; --r-somevar: [[ $somevar ]]; --someevent: [[ @mousemove.clientX[#myelement] ]]; --r-mx: [[ &add(&num(^mouse_clientX), &add(101px,22), 60) ]]px; --r-my: [[ &sub(^mouse_clientY, 20) ]]px;"; str.match(eventRegex);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
with /g
with /

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36

Browser/OS: Chrome 80 on Windows

View result in a separate tab

Test name	Executions per second
with /g	1298964.8 Ops/sec
with /	1298495.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is tested?**

The provided benchmark tests two different options for regular expression flag usage in JavaScript: `/g` (global) and `/`. The test aims to measure which approach performs better in terms of execution speed.

**Options comparison**

There are two approaches being compared:

1. **/g**: This flag enables the global mode, which allows the regex engine to search for matches across multiple lines of input. When used with the `match()` method, it returns an array of all matches found anywhere in the string.
2. **/**: This is a shorthand notation that can be used interchangeably with `/` followed by any flags (e.g., `/g`, `/i`, etc.). In this case, we assume that there are no additional flags specified.

**Pros and Cons**

Here's a brief summary of each approach:

* **/g**:
	+ Pros: Can find matches across multiple lines, which might be useful in certain scenarios.
	+ Cons: May perform slower due to the added complexity of searching across multiple lines.
* **/**: (Assuming no additional flags)
	+ Pros: Simple and straightforward, can be faster than `/g` since it doesn't require searching across multiple lines.
	+ Cons: May not find matches that span multiple lines.

**Library usage**

In this benchmark, the `match()` method is used to test regular expressions. The `match()` method belongs to the String prototype in JavaScript and is responsible for searching a string for a match against a specified pattern.

**Special JS feature/syntax**

None of the code snippets provided use any special JavaScript features or syntax beyond standard regex notation. If you were to experiment with more advanced techniques, such as ES6 classes, async/await, or Promises, it might alter the benchmark results significantly.

**Other alternatives**

To create similar benchmarks on MeasureThat.net or elsewhere, consider the following:

1. Use different regex patterns that test various aspects of regex performance, like speed, memory usage, or string manipulation.
2. Experiment with different JavaScript engines or versions to see how they compare in terms of performance.
3. Consider using other benchmarking frameworks or libraries, such as V8.js, Stryke, or jsbench.

Keep in mind that the results may vary depending on the specific test cases, environment, and system configuration.

Hope this explanation helps!

Related benchmarks:

regex /g vs / (version: 0)

Comparing performance of: with /g vs with /

Created: 4 years ago by: Guest

Jump to the latest result

with /g

with /

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