Benchmark: RegExp constructor vs literal vs inline 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')
Inline literal
/^[0-9a-fA-F]{24}$/.test('132abc67219f019afe12901a')

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Literal

3.4M/s

new RegExp()

3.4M/s

Inline literal

3.4M/s

View exact numbers

✓ Literal: 3,405,657 ops/sec
• new RegExp(): 3,379,732 ops/sec
• Inline literal: 3,371,223 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
Inline literal

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Firefox 138 on Windows

View result in a separate tab

Inline literal

3.5M/s

new RegExp()

3.4M/s

Literal

3.4M/s

View exact numbers

Test name	Executions per second
✓ Inline literal	3,473,715 Ops/sec
new RegExp()	3,444,816 Ops/sec
Literal	3,384,303 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark is designed to compare the performance of three different approaches:

1. **RegExp constructor**: Creating a new `RegExp` object using the `new RegExp()` syntax.
2. **Literal regex**: Using a regular expression literal, enclosed in forward slashes (`/.../`).
3. **Inline literal**: Using an inline regular expression, with no delimiters (e.g., `/^[0-9a-fA-F]{24}$/.test('string')`).

**Options Compared**

The three options are compared in terms of their performance, measured by the number of executions per second.

**Pros and Cons of Each Approach**

1. **RegExp constructor**:
	* Pros: Can be more readable and maintainable for complex regular expressions.
	* Cons: May incur a performance overhead due to object creation and parsing.
2. **Literal regex**:
	* Pros: Can be faster since the browser can optimize literals as simple patterns.
	* Cons: May not be as readable or maintainable, especially for complex patterns.
3. **Inline literal**:
	* Pros: Can be even faster than literal regex, as it avoids the overhead of creating a new RegExp object.
	* Cons: May be less readable and more prone to errors due to the lack of explicit delimiters.

**Library Used**

None explicitly mentioned in this benchmark definition. However, in other benchmarks on MeasureThat.net, libraries like `lodash` or `moment.js` are often used for specific tasks.

**Special JS Feature or Syntax (Not Applicable)**

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

**Other Alternatives**

If you need to test similar regular expression performance, consider using other approaches:

1. **Using a regex engine**: Some browsers have built-in regex engines that can be used for optimized testing.
2. **Using a virtual DOM**: Some libraries, like React, use virtual DOMs to optimize rendering and can also be used for benchmarking.
3. **Using a custom parser**: For extremely performance-critical scenarios, writing a custom parser or using an existing one (e.g., `jsregex`) might be necessary.

Keep in mind that these alternatives may require additional setup, expertise, and resources compared to the original benchmark definition on MeasureThat.net.

RegExp constructor vs literal vs inline literal (version: 0)

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

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

Created: 3 years ago by: Guest

Go to the latest result

new RegExp()

Literal

Inline literal

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 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 vs inline literal (version: 0)

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

Comparing performance of: new RegExp() vs Literal vs Inline literal

Created: 3 years ago by: Guest

Go to the latest result

new RegExp()

Literal

Inline literal

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 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 vs Inline literal`