Benchmark: regex replace vs replaceAll vs replace in loop V1.1

regex replace vs replaceAll vs replace in loop V1.1 (version: 1)

replace all whitespaces from string. what is faster? replace() with regex with global flag or without global flag and using a loop?

Comparing performance of: replace vs replaceAll vs replace in a loop without g flag vs replace in a loop, count matches with g flag, replace without g flag

Created: 5 years ago by: Registered User

Jump to the latest result

Script Preparation code:

function replaceAll(str, regexp, newValue) {
    let newStr = str;

    while (regexp.test(newStr)) {
        newStr = newStr.replace(regexp, newValue);
    }

    return newStr;
}

function replaceAllCountMatches(str, regexp, newValue) {
    let newStr = str;
    
    for (let i = 0; i < matchesCounter; i++) {
        newStr = newStr.replace(regexp, newValue);
    }

    return newStr;
}

var str = 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis a';
var matchesCounter = (str.match(/\s+/g) || []).length;
var result;

Tests:

replace
result = str.replace(/\s+/g, '');
replaceAll
result = str.replaceAll(/\s+/g, '');
replace in a loop without g flag
result = replaceAll(str, /\s+/, '');
replace in a loop, count matches with g flag, replace without g flag
result = replaceAllCountMatches(str, /\s+/, '');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
replace
replaceAll
replace in a loop without g flag
replace in a loop, count matches with g flag, replace without g flag

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
replace	329008.9 Ops/sec
replaceAll	325797.0 Ops/sec
replace in a loop without g flag	14223.7 Ops/sec
replace in a loop, count matches with g flag, replace without g flag	22182.5 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!

**Benchmark Overview**

The provided JSON represents a benchmark that compares three approaches to replacing all whitespaces from a given string:

1. `str.replace()` with regex and global flag (`/\\s+/g`).
2. `replaceAll()` function (a custom implementation) with regex and global flag (`/\\s+g`).
3. Replacing all whitespace characters in a loop without using the global flag (`replace()`).

**Options Comparison**

The three options are compared to determine which one is faster.

* **Option 1: `str.replace()` with regex and global flag (`/\\s+/g`)**:
	+ Pros: Built-in JavaScript function, efficient use of regular expressions.
	+ Cons: Requires additional overhead for creating a regex object.
* **Option 2: `replaceAll()` function (custom implementation) with regex and global flag (`/\\s+g`)**:
	+ Pros: Custom implementation allows for fine-tuning performance optimization.
	+ Cons: Requires writing custom code, may not be as efficient as built-in functions.
* **Option 3: Replacing all whitespace characters in a loop without using the global flag (`replace()`)**:
	+ Pros: Simple and straightforward approach.
	+ Cons: Requires manual iteration over the string, may be slower than regex-based approaches.

**Performance Considerations**

The benchmark results show that:

* `str.replace()` with regex and global flag is the fastest option (average executions per second: 329,008.91 for Chrome 129).
* The custom `replaceAll()` function with regex and global flag is significantly slower than the built-in `replace()` method.
* Replacing all whitespace characters in a loop without using the global flag is the slowest option (average executions per second: 14,230.71 for Chrome 129).

**Library Usage**

The custom `replaceAll()` function uses a library ( likely written by the creator of MeasureThat.net) to implement the regular expression replacement functionality.

**Special JavaScript Feature/Syntax**

None mentioned in this benchmark.

Related benchmarks: