Benchmark: new RegExp test - MeasureThat.net

Script Preparation code:

const reg = new RegExp(/^[0-9]*$/);

Tests:

declare
reg.test(1)
new RegExp
(new RegExp(/^[0-9]*$/)).test(1)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
declare
new RegExp

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested.

**Benchmark Definition**

The benchmark definition is a JSON object that contains metadata about the test case, such as its name and description. In this case:

* `Name`: "new RegExp test" - This is the name of the benchmark.
* `Description`: null - There is no description provided for this benchmark.
* `Script Preparation Code`: "const reg = new RegExp(/^[0-9]*$/);" - This code is used to prepare the script before running the benchmark. In this case, it creates a new regular expression (`RegExp`) that matches any string starting with digits (`[0-9]*$`).
* `Html Preparation Code`: null - There is no HTML preparation code provided.

**Individual Test Cases**

The test cases are an array of objects that define specific tests to be executed. In this case, there are two test cases:

1. `"Benchmark Definition": "reg.test(1)"`, `"Test Name": "declare"`
	* This test case calls the `test` method on the regular expression created earlier (`reg`) with the input `1`.
2. `"Benchmark Definition": "(new RegExp(/^[0-9]*$/)).test(1)"`, `"Test Name": "new RegExp"`
	* This test case creates a new regular expression using the same pattern as before, and then calls its `test` method with the input `1`.

**What's being tested**

These two test cases are testing the performance of creating a new regular expression (`RegExp`) versus calling the `test` method on an existing one.

**Options compared**

There are two approaches being compared:

1. **Creating a new RegExp**: The first test case creates a new regular expression and then calls its `test` method.
2. **Calling test() on an existing RegExp**: The second test case creates a new regular expression, stores it in a variable, and then calls the `test` method on that variable.

**Pros and Cons of each approach**

* Creating a new RegExp:
	+ Pros: Avoids unnecessary overhead of creating a new object.
	+ Cons: Creates an additional object, which might incur some overhead due to memory allocation and garbage collection.
* Calling test() on an existing RegExp:
	+ Pros: Reuses the existing object, avoiding unnecessary creation and potential overhead.
	+ Cons: Might involve some additional overhead due to looking up the `test` method on the existing object.

**Library (if applicable)**

There is no explicit library mentioned in this benchmark. However, regular expressions are a built-in feature of JavaScript.

**Special JS features or syntax**

There are no special JS features or syntax mentioned in this benchmark. The code uses standard JavaScript features like variables, `new` keyword, and method calls.

**Other alternatives**

If you wanted to test the performance of creating a new RegExp versus calling other methods on an existing object, you could modify the benchmark definition to include additional test cases, such as:

* Creating a new RegExp vs. using a function constructor
* Creating a new RegExp vs. using a class syntax
* Using `RegExp.prototype.test()` vs. `RegExp.prototype.exec()`

Latest run results:

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

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

Browser/OS: Chrome 102 on Windows

View result in a separate tab

Test name	Executions per second
declare	0.0 Ops/sec
new RegExp	3105109.5 Ops/sec

Related benchmarks:

new RegExp test (version: 0)

Comparing performance of: declare vs new RegExp

Created: 2 years ago by: Guest

Jump to the latest result

declare

new RegExp

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