Benchmark: RegExp constructor vs literal

Script Preparation code:

var reConstructor = new RegExp('^[0-9a-fA-F]{24}$')
var reLiteral = /^[0-9a-fA-F]{24}$/

Tests:

new RegExp()
reConstructor.test('132abc67219f019afe12901a')
Literal
reLiteral.test('132abc67219f019afe12901a')

Historical Performance Data aggregated from 74 community runs

Desktop Results:

Chrome 58 runs

new RegExp()

13.2M/s

Literal

13.1M/s

View exact numbers

✓ new RegExp(): 13,217,012 ops/sec
• Literal: 13,076,204 ops/sec

Firefox 16 runs

new RegExp()

16.8M/s

Literal

16.7M/s

View exact numbers

✓ new RegExp(): 16,764,740 ops/sec
• Literal: 16,696,546 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new RegExp()
Literal

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 6 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0

Browser/OS: Firefox 147 on Windows

View result in a separate tab

Literal

10.8M/s

new RegExp()

10.3M/s

View exact numbers

Test name	Executions per second
✓ Literal	10,762,221 Ops/sec
new RegExp()	10,342,833 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**What is being tested:**

The benchmark compares the performance of two approaches when testing a string using a regular expression:

1. **RegExp constructor**: Creating a new `RegExp` object with a specified pattern and flags, as shown in the "Script Preparation Code": `var reConstructor = new RegExp('^[0-9a-fA-F]{24}$')`.
2. **Literal regex**: Using a pre-defined string literal regex pattern, as shown in the "Html Preparation Code": `var reLiteral = /^[0-9a-fA-F]{24}$/`.

**Options compared:**

The benchmark is comparing two options:

* Option 1: Creating a new `RegExp` object using the constructor.
* Option 2: Using a pre-defined literal regex pattern.

**Pros and Cons of each approach:**

1. **RegExp constructor (Option 1)**:
	* Pros:
		+ Can be more flexible, as you can customize the pattern and flags to suit your needs.
		+ May provide better performance for complex patterns or when working with large datasets.
	* Cons:
		+ Can lead to slower performance due to the overhead of creating a new object.
2. **Literal regex (Option 2)**:
	* Pros:
		+ Typically faster, as it avoids the overhead of creating a new `RegExp` object.
		+ Easier to read and maintain, as the pattern is explicitly defined.
	* Cons:
		+ Less flexible than the constructor approach, as you're limited to pre-defined patterns.

**Library/Functionality:**

The benchmark uses JavaScript's built-in `test()` method on a string object, which performs a case-sensitive match against a regular expression. The `test()` method returns `true` if the entire string matches the regex pattern or there is an error, otherwise it returns `false`.

**Special JS feature/syntax:**

This benchmark does not use any special JavaScript features or syntax beyond what's required for testing.

**Other alternatives:**

If you want to explore alternative approaches, here are a few options:

* **Use a different string object method**: Instead of using `test()`, you could try using other string methods like `match()` or `replace()` with regex patterns.
* **Compare performance with different flags**: You could modify the RegExp constructor to use different flags (e.g., `g`, `i`, etc.) and compare performance to see how they affect execution speed.
* **Use a faster regex engine**: Some JavaScript engines, like V8 in Chrome, have built-in support for more efficient regex matching.

RegExp constructor vs literal (version: 1)

Testing performance when using a new RegExp object vs a literal regex

Comparing performance of: `new RegExp() vs Literal`

Created: 8 years ago by: Registered User

Go to the latest result

new RegExp()

Literal

Historical Performance Data aggregated from 74 community runs

Desktop Results:

Chrome 58 runs

Firefox 16 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

RegExp constructor vs literal (version: 1)

Testing performance when using a new RegExp object vs a literal regex

Comparing performance of: new RegExp() vs Literal

Created: 8 years ago by: Registered User

Go to the latest result

new RegExp()

Literal

Historical Performance Data aggregated from 74 community runs

Desktop Results:

Chrome 58 runs

Firefox 16 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `new RegExp() vs Literal`