Benchmark: RegExp inside vs outside loop

Script Preparation code:

const SIZE = 100000;
var chars = new Array(SIZE);
for (let index = 0; index < SIZE; index++) {
  chars[index] = String.fromCodePoint(
    Math.floor( Math.random() * 0x80 )
  );
}
var newChars = new Array(SIZE);

Tests:

Outside, literal
const regexp = /[\x00-\x1f\x7f]/g; for (const char of chars) { newChars.push(char.replace(regexp, "")); } console.log(newChars);
Inside, literal
for (const char of chars) { newChars.push(char.replace(/[\x00-\x1f\x7f]/g, "")); } console.log(newChars);
Outside, object
const regexp = new RegExp("[\x00-\x1f\x7f]"); for (const char of chars) { newChars.push(char.replace(regexp, "")); } console.log(newChars);
Inside, object
for (const char of chars) { newChars.push(char.replace(new RegExp("[\x00-\x1f\x7f]"), "")); } console.log(newChars);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Outside, literal
Inside, literal
Outside, object
Inside, object

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:109.0) Gecko/20100101 Firefox/114.0

Browser/OS: Firefox 114 on Windows

View result in a separate tab

Test name	Executions per second
Outside, literal	90.7 Ops/sec
Inside, literal	96.2 Ops/sec
Outside, object	114.6 Ops/sec
Inside, object	58.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases to understand what's being tested.

**Benchmark Definition**

The benchmark measures the performance difference between three approaches when removing Unicode characters (specifically, ASCII characters with codes 0-31, 127, or 239) from an array of randomly generated Unicode strings using regular expressions.

**Script Preparation Code**

The script prepares two arrays: `chars` and `newChars`. `chars` contains 100,000 random Unicode strings, while `newChars` is initially empty. The script uses a loop to populate `newChars` by iterating over each character in `chars`.

**Html Preparation Code**

There is no HTML preparation code provided.

**Individual Test Cases**

The benchmark consists of four test cases:

1. **Outside, literal**: A regular expression (`regexp`) is defined as a string literal outside the loop, and then used to remove Unicode characters from each character in `chars`.
2. **Inside, literal**: The same regular expression is defined inside the loop, but still used to remove Unicode characters from each character in `chars`. This test case compares the performance difference between defining the regex outside vs inside the loop.
3. **Outside, object**: A new RegExp object is created with a character class (`new RegExp("[\\x00-\\x1f\\x7f]")`) and used to remove Unicode characters from each character in `chars`. This test case compares the performance difference between using a regular expression as a string literal vs an RegExp object.
4. **Inside, object**: The same RegExp object is defined inside the loop, but used to remove Unicode characters from each character in `chars`.

**Pros and Cons of Different Approaches**

1. **Outside, literal**:
	* Pros: Can be faster because the regex is only compiled once.
	* Cons: May not be as flexible since the character class is defined outside the loop.
2. **Inside, literal**:
	* Pros: More flexible since the character class can change dynamically.
	* Cons: Slower due to recompilation of the regular expression on each iteration.
3. **Outside, object**:
	* Pros: Can be faster because the regex is only compiled once and can be more efficient with caching.
	* Cons: Requires more memory to store the RegExp object.
4. **Inside, object**:
	* Pros: More flexible since the character class can change dynamically.
	* Cons: Slower due to recompilation of the regular expression on each iteration.

**Library Used**

The benchmark uses the built-in `String.prototype.replace()` method with a regular expression, which is implemented in C++ by the JavaScript engine. No additional libraries are required.

**Special JS Feature or Syntax**

No special features or syntax are used in this benchmark. It's purely focused on testing performance variations of removing Unicode characters from an array using different approaches.

Now, when looking at the latest benchmark result, we can see that:

* The "Outside, object" test case performed the best with 114 executions per second.
* The "Inside, literal" and "Outside, literal" tests cases are relatively close in performance, but the "Outside, literal" test case is slightly faster.

**Other Alternatives**

To measure performance variations similar to this benchmark, other alternatives could include:

1. **Measuring string concatenation performance**: This can help evaluate the efficiency of different methods for building strings.
2. **Testing array manipulation performance**: This can help evaluate the efficiency of different algorithms for manipulating arrays, such as sorting or searching.
3. **Benchmarking JSON parsing and generation**: This can help evaluate the efficiency of different libraries or implementations for parsing and generating JSON data.

Keep in mind that the choice of alternative benchmark depends on the specific requirements and goals of the project.

Related benchmarks:

RegExp inside vs outside loop (version: 0)

RegExp inside vs outside loop

Comparing performance of: Outside, literal vs Inside, literal vs Outside, object vs Inside, object

Created: one year ago by: Guest

Jump to the latest result

Outside, literal

Inside, literal

Outside, object

Inside, object

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