Benchmark: Regexp creation vs memoization

Script Preparation code:

var cache = {}
const regexps = [
  /^((?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))*$/,
  /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6011[0-9]{12}|622((12[6-9]|1[3-9][0-9])|([2-8][0-9][0-9])|(9(([0-1][0-9])|(2[0-5]))))[0-9]{10}|64[4-9][0-9]{13}|65[0-9]{14}|3(?:0[0-5]|[68][0-9])[0-9]{11}|3[47][0-9]{13})*$/,
  /[^@/]+@[^@/]+/,
  /\\s+/,
  /[^a-zA-Z0-9]/,
  /^$/,
  /^[1-9]+[0-9]*$/,
  /(^\d*\.?\d*[0-9]+\d*$)|(^[0-9]+\d*\.\d*$)/,
  /^-?[0-9]{0,2}(\.[0-9]{1,2})?$|^-?(100)(\.[0]{1,2})?$/,
]
const sources = regexps.map(r => r.source)
regexps.forEach(r => {
  cache[r.source] = r
})

const n = sources.length
const floor = Math.floor
const random = Math.random
function getRandomSource () {
  return sources[floor(random() * n)]
}

​x
 
var cache = {}const regexps = [  /^((?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))*$/,  /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6011[0-9]{12}|622((12[6-9]|1[3-9][0-9])|([2-8][0-9][0-9])|(9(([0-1][0-9])|(2[0-5]))))[0-9]{10}|64[4-9][0-9]{13}|65[0-9]{14}|3(?:0[0-5]|[68][0-9])[0-9]{11}|3[47][0-9]{13})*$/,  /[^@/]+@[^@/]+/,  /\\s+/,  /[^a-zA-Z0-9]/,  /^$/,  /^[1-9]+[0-9]*$/,  /(^\d*\.?\d*[0-9]+\d*$)|(^[0-9]+\d*\.\d*$)/,  /^-?[0-9]{0,2}(\.[0-9]{1,2})?$|^-?(100)(\.[0]{1,2})?$/,]const sources = regexps.map(r => r.source)regexps.forEach(r => {  cache[r.source] = r})​const n = sources.lengthconst floor = Math.floorconst random = Math.randomfunction getRandomSource () {  return sources[floor(random() * n)]}

Tests:

constructor
window.result = new RegExp(getRandomSource())
window.result = new RegExp(getRandomSource())
memoize
window.result = cache[getRandomSource()]
window.result = cache[getRandomSource()]
common boilerplate
window.result = getRandomSource()
window.result = getRandomSource()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
constructor
memoize
common boilerplate

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 13; SM-G780G) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Mobile Safari/537.36 EdgA/108.0.1462.54

Browser/OS: Chrome Mobile 108 on Android

View result in a separate tab

Test name	Executions per second
constructor	799634.8 Ops/sec
memoize	1355083.5 Ops/sec
common boilerplate	1731009.5 Ops/sec

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

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

Benchmark Definition

The test compares two approaches to creating regular expressions (regexps) in JavaScript:

Constructor: This approach creates a new regexp object every time it's needed, without caching the results.
Memoization: This approach caches the compiled regexps in an object (cache) and reuses them instead of recreating them from scratch.

Options Compared

The two options being compared are:

Creating a new regexp object from scratch (constructor)
Caching the compiled regexp objects (memoization)

Pros and Cons of Each Approach

Constructor

Pros:

Easy to implement
No overhead in terms of memory usage or performance impact on first use

Cons:

Creates a new regexp object every time it's needed, which can be inefficient if the same regexp is used multiple times.
Can lead to performance issues if the number of regexps grows large.

Memoization

Pros:

Reuses cached compiled regexps, reducing memory usage and improving performance for repeated use.
Reduces the overhead of creating a new regexp object from scratch.

Cons:

Requires additional memory to store the cache.
May increase memory usage if the cache grows too large.

Library Used

In this benchmark, no external libraries are used. The regexps are defined directly in the JavaScript code.

Special JS Feature/Syntax (None)

There are no special JavaScript features or syntaxes being tested in this benchmark.

Other Considerations

When deciding between these two approaches, consider the following:

If you expect to use the same regexp multiple times, memoization might be a better choice.
If you're working with a large number of unique regexps, memoization could help reduce memory usage and improve performance.
If simplicity is more important than optimization, the constructor approach might be sufficient.

Alternatives

Other approaches to creating regexps in JavaScript include:

Using a library like RegExCache or RegExp- cache to cache compiled regexps.
Using a JavaScript engine that supports Just-In-Time (JIT) compilation of regexps, which can improve performance.
Using a different programming language or framework that provides built-in support for caching and reusing compiled regexps.

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The test compares two approaches to creating regular expressions (regexps) in JavaScript:

1. **Constructor**: This approach creates a new regexp object every time it's needed, without caching the results.
2. **Memoization**: This approach caches the compiled regexps in an object (`cache`) and reuses them instead of recreating them from scratch.

**Options Compared**

The two options being compared are:

* Creating a new regexp object from scratch (constructor)
* Caching the compiled regexp objects (memoization)

**Pros and Cons of Each Approach**

### Constructor

Pros:

* Easy to implement
* No overhead in terms of memory usage or performance impact on first use

Cons:

* Creates a new regexp object every time it's needed, which can be inefficient if the same regexp is used multiple times.
* Can lead to performance issues if the number of regexps grows large.

### Memoization

Pros:

* Reuses cached compiled regexps, reducing memory usage and improving performance for repeated use.
* Reduces the overhead of creating a new regexp object from scratch.

Cons:

* Requires additional memory to store the cache.
* May increase memory usage if the cache grows too large.

**Library Used**

In this benchmark, no external libraries are used. The regexps are defined directly in the JavaScript code.

**Special JS Feature/Syntax (None)**

There are no special JavaScript features or syntaxes being tested in this benchmark.

**Other Considerations**

When deciding between these two approaches, consider the following:

* If you expect to use the same regexp multiple times, memoization might be a better choice.
* If you're working with a large number of unique regexps, memoization could help reduce memory usage and improve performance.
* If simplicity is more important than optimization, the constructor approach might be sufficient.

**Alternatives**

Other approaches to creating regexps in JavaScript include:

* Using a library like RegExCache or RegExp- cache to cache compiled regexps.
* Using a JavaScript engine that supports Just-In-Time (JIT) compilation of regexps, which can improve performance.
* Using a different programming language or framework that provides built-in support for caching and reusing compiled regexps.

Related benchmarks:

Regexp creation vs memoization (version: 7)

I need to obtain and use regexps from a string. I'm testing wether I should cache regexps or just construct them on demand.

Comparing performance of: constructor vs memoize vs common boilerplate

Created: 7 years ago by: Registered User

Jump to the latest result

constructor

memoize

common boilerplate

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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

Constructor

Memoization