Benchmark: string.replace vs regexp.matchAll vs regexp.exec

Tests:

string.replace
const s = 'Apple Apple Apple Apple Apple'; const r = new RegExp('(^|\\P{L})(Apple)($|\\P{L})', 'giu'); s.replace(r, '*****');
AخA

const s = 'Apple Apple Apple Apple Apple';
const r = new RegExp('(^|\\P{L})(Apple)($|\\P{L})', 'giu');
s.replace(r, '*****');
regexp.matchAll
const s = 'Apple Apple Apple Apple Apple'; const r = new RegExp('(^|\\P{L})(Apple)($|\\P{L})', 'giu'); const n = []; const matches = [...s.matchAll(r)]; matches.forEach((match) => { // do something // n.push(match.index); });
const s = 'Apple Apple Apple Apple Apple';
const r = new RegExp('(^|\\P{L})(Apple)($|\\P{L})', 'giu');
const n = [];
const matches = [...s.matchAll(r)];
matches.forEach((match) => {
// do something
// n.push(match.index);
});

regexp.exec

const s = 'Apple  Apple  Apple  Apple  Apple';
const r = new RegExp('(^|\\P{L})(Apple)($|\\P{L})', 'giu');
const n = [];
let execResults;
while ((execResults = r.exec(s)) !== null) {
  // do something
  // n.push(execResults.index);
}

 
const s = 'Apple  Apple  Apple  Apple  Apple';const r = new RegExp('(^|\\P{L})(Apple)($|\\P{L})', 'giu');const n = [];let execResults;while ((execResults = r.exec(s)) !== null) {  // do something  // n.push(execResults.index);}

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
string.replace
regexp.matchAll
regexp.exec

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
string.replace	4464464.0 Ops/sec
regexp.matchAll	1400121.5 Ops/sec
regexp.exec	2547809.5 Ops/sec

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

Let's break down the provided benchmark and explain what is being tested, compared, and their pros and cons.

Benchmark Overview

The test cases compare three different approaches for processing strings: string.replace, regexp.matchAll, and regexp.exec. The goal is to determine which approach is fastest.

Options Compared

string.replace: This method replaces occurrences of a pattern in a string.
regexp.matchAll: This method returns all matches of a regular expression in a string.
regexp.exec: This method executes the regex engine on a given string, returning a match array.

Pros and Cons

string.replace:
- Pros: Simple to use, efficient for simple replacements.
- Cons: Can be slow for complex patterns or large strings.
regexp.matchAll:
- Pros: Returns all matches, can be useful for finding multiple occurrences.
- Cons: May consume more memory and CPU resources than other methods.
regexp.exec:
- Pros: Efficient for iterating over a string and finding matches one by one.
- Cons: Requires manual looping to iterate over matches.

Library

In the test cases, the regular expression library used is built-in JavaScript's RegExp. This is because it's part of the standard JavaScript specification.

Special JS Feature or Syntax

There are no special JavaScript features or syntax used in these benchmark tests. However, there are some notable features of the regex engine:

The regular expression pattern uses \P{L} to match non-lowercase letters.
The giu flags at the end of the pattern enable case-insensitive matching and Unicode properties.

Benchmark Preparation Code

The preparation code is empty for all test cases, which means that the benchmarks start with a clean slate. This is good because it allows each approach to be tested in isolation without any overhead from previous runs.

Other Alternatives

If these approaches are not sufficient or desired, other alternatives could include:

Using a dedicated regex engine like PCRE (Perl-Compatible Regular Expressions) or Java's Pattern class.
Implementing custom string processing algorithms for better performance.
Using a different programming language with built-in regex support.

Keep in mind that each alternative may have its own set of trade-offs and considerations.

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested, compared, and their pros and cons.

**Benchmark Overview**

The test cases compare three different approaches for processing strings: `string.replace`, `regexp.matchAll`, and `regexp.exec`. The goal is to determine which approach is fastest.

**Options Compared**

1. **string.replace**: This method replaces occurrences of a pattern in a string.
2. **regexp.matchAll**: This method returns all matches of a regular expression in a string.
3. **regexp.exec**: This method executes the regex engine on a given string, returning a match array.

**Pros and Cons**

* `string.replace`:
	+ Pros: Simple to use, efficient for simple replacements.
	+ Cons: Can be slow for complex patterns or large strings.
* `regexp.matchAll`:
	+ Pros: Returns all matches, can be useful for finding multiple occurrences.
	+ Cons: May consume more memory and CPU resources than other methods.
* `regexp.exec`:
	+ Pros: Efficient for iterating over a string and finding matches one by one.
	+ Cons: Requires manual looping to iterate over matches.

**Library**

In the test cases, the regular expression library used is built-in JavaScript's `RegExp`. This is because it's part of the standard JavaScript specification.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax used in these benchmark tests. However, there are some notable features of the regex engine:

* The regular expression pattern uses `\P{L}` to match non-lowercase letters.
* The `giu` flags at the end of the pattern enable case-insensitive matching and Unicode properties.

**Benchmark Preparation Code**

**Other Alternatives**

If these approaches are not sufficient or desired, other alternatives could include:

* Using a dedicated regex engine like PCRE (Perl-Compatible Regular Expressions) or Java's `Pattern` class.
* Implementing custom string processing algorithms for better performance.
* Using a different programming language with built-in regex support.

Keep in mind that each alternative may have its own set of trade-offs and considerations.

Related benchmarks:

string.replace vs regexp.matchAll vs regexp.exec (version: 0)

Comparing performance of: string.replace vs regexp.matchAll vs regexp.exec

Created: 2 years ago by: Guest

Jump to the latest result

string.replace

regexp.matchAll